var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __typeError = (msg) => {
  throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to2, from2, except, desc) => {
  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
    for (let key of __getOwnPropNames(from2))
      if (!__hasOwnProp.call(to2, key) && key !== except)
        __defProp(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
  }
  return to2;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);

// node_modules/.pnpm/moment@2.30.1/node_modules/moment/moment.js
var require_moment = __commonJS({
  "node_modules/.pnpm/moment@2.30.1/node_modules/moment/moment.js"(exports, module2) {
    (function(global, factory) {
      typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global.moment = factory();
    })(exports, (function() {
      "use strict";
      var hookCallback;
      function hooks() {
        return hookCallback.apply(null, arguments);
      }
      function setHookCallback(callback2) {
        hookCallback = callback2;
      }
      function isArray2(input) {
        return input instanceof Array || Object.prototype.toString.call(input) === "[object Array]";
      }
      function isObject2(input) {
        return input != null && Object.prototype.toString.call(input) === "[object Object]";
      }
      function hasOwnProp(a2, b2) {
        return Object.prototype.hasOwnProperty.call(a2, b2);
      }
      function isObjectEmpty(obj) {
        if (Object.getOwnPropertyNames) {
          return Object.getOwnPropertyNames(obj).length === 0;
        } else {
          var k;
          for (k in obj) {
            if (hasOwnProp(obj, k)) {
              return false;
            }
          }
          return true;
        }
      }
      function isUndefined(input) {
        return input === void 0;
      }
      function isNumber2(input) {
        return typeof input === "number" || Object.prototype.toString.call(input) === "[object Number]";
      }
      function isDate(input) {
        return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
      }
      function map3(arr, fn2) {
        var res = [], i2, arrLen = arr.length;
        for (i2 = 0; i2 < arrLen; ++i2) {
          res.push(fn2(arr[i2], i2));
        }
        return res;
      }
      function extend(a2, b2) {
        for (var i2 in b2) {
          if (hasOwnProp(b2, i2)) {
            a2[i2] = b2[i2];
          }
        }
        if (hasOwnProp(b2, "toString")) {
          a2.toString = b2.toString;
        }
        if (hasOwnProp(b2, "valueOf")) {
          a2.valueOf = b2.valueOf;
        }
        return a2;
      }
      function createUTC(input, format2, locale2, strict) {
        return createLocalOrUTC(input, format2, locale2, strict, true).utc();
      }
      function defaultParsingFlags() {
        return {
          empty: false,
          unusedTokens: [],
          unusedInput: [],
          overflow: -2,
          charsLeftOver: 0,
          nullInput: false,
          invalidEra: null,
          invalidMonth: null,
          invalidFormat: false,
          userInvalidated: false,
          iso: false,
          parsedDateParts: [],
          era: null,
          meridiem: null,
          rfc2822: false,
          weekdayMismatch: false
        };
      }
      function getParsingFlags(m2) {
        if (m2._pf == null) {
          m2._pf = defaultParsingFlags();
        }
        return m2._pf;
      }
      var some;
      if (Array.prototype.some) {
        some = Array.prototype.some;
      } else {
        some = function(fun) {
          var t3 = Object(this), len = t3.length >>> 0, i2;
          for (i2 = 0; i2 < len; i2++) {
            if (i2 in t3 && fun.call(this, t3[i2], i2, t3)) {
              return true;
            }
          }
          return false;
        };
      }
      function isValid(m2) {
        var flags = null, parsedParts = false, isNowValid = m2._d && !isNaN(m2._d.getTime());
        if (isNowValid) {
          flags = getParsingFlags(m2);
          parsedParts = some.call(flags.parsedDateParts, function(i2) {
            return i2 != null;
          });
          isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
          if (m2._strict) {
            isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === void 0;
          }
        }
        if (Object.isFrozen == null || !Object.isFrozen(m2)) {
          m2._isValid = isNowValid;
        } else {
          return isNowValid;
        }
        return m2._isValid;
      }
      function createInvalid(flags) {
        var m2 = createUTC(NaN);
        if (flags != null) {
          extend(getParsingFlags(m2), flags);
        } else {
          getParsingFlags(m2).userInvalidated = true;
        }
        return m2;
      }
      var momentProperties = hooks.momentProperties = [], updateInProgress = false;
      function copyConfig(to3, from3) {
        var i2, prop, val, momentPropertiesLen = momentProperties.length;
        if (!isUndefined(from3._isAMomentObject)) {
          to3._isAMomentObject = from3._isAMomentObject;
        }
        if (!isUndefined(from3._i)) {
          to3._i = from3._i;
        }
        if (!isUndefined(from3._f)) {
          to3._f = from3._f;
        }
        if (!isUndefined(from3._l)) {
          to3._l = from3._l;
        }
        if (!isUndefined(from3._strict)) {
          to3._strict = from3._strict;
        }
        if (!isUndefined(from3._tzm)) {
          to3._tzm = from3._tzm;
        }
        if (!isUndefined(from3._isUTC)) {
          to3._isUTC = from3._isUTC;
        }
        if (!isUndefined(from3._offset)) {
          to3._offset = from3._offset;
        }
        if (!isUndefined(from3._pf)) {
          to3._pf = getParsingFlags(from3);
        }
        if (!isUndefined(from3._locale)) {
          to3._locale = from3._locale;
        }
        if (momentPropertiesLen > 0) {
          for (i2 = 0; i2 < momentPropertiesLen; i2++) {
            prop = momentProperties[i2];
            val = from3[prop];
            if (!isUndefined(val)) {
              to3[prop] = val;
            }
          }
        }
        return to3;
      }
      function Moment6(config) {
        copyConfig(this, config);
        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
        if (!this.isValid()) {
          this._d = /* @__PURE__ */ new Date(NaN);
        }
        if (updateInProgress === false) {
          updateInProgress = true;
          hooks.updateOffset(this);
          updateInProgress = false;
        }
      }
      function isMoment(obj) {
        return obj instanceof Moment6 || obj != null && obj._isAMomentObject != null;
      }
      function warn(msg) {
        if (hooks.suppressDeprecationWarnings === false && typeof console !== "undefined" && console.warn) {
          console.warn("Deprecation warning: " + msg);
        }
      }
      function deprecate(msg, fn2) {
        var firstTime = true;
        return extend(function() {
          if (hooks.deprecationHandler != null) {
            hooks.deprecationHandler(null, msg);
          }
          if (firstTime) {
            var args = [], arg, i2, key, argLen = arguments.length;
            for (i2 = 0; i2 < argLen; i2++) {
              arg = "";
              if (typeof arguments[i2] === "object") {
                arg += "\n[" + i2 + "] ";
                for (key in arguments[0]) {
                  if (hasOwnProp(arguments[0], key)) {
                    arg += key + ": " + arguments[0][key] + ", ";
                  }
                }
                arg = arg.slice(0, -2);
              } else {
                arg = arguments[i2];
              }
              args.push(arg);
            }
            warn(
              msg + "\nArguments: " + Array.prototype.slice.call(args).join("") + "\n" + new Error().stack
            );
            firstTime = false;
          }
          return fn2.apply(this, arguments);
        }, fn2);
      }
      var deprecations = {};
      function deprecateSimple(name, msg) {
        if (hooks.deprecationHandler != null) {
          hooks.deprecationHandler(name, msg);
        }
        if (!deprecations[name]) {
          warn(msg);
          deprecations[name] = true;
        }
      }
      hooks.suppressDeprecationWarnings = false;
      hooks.deprecationHandler = null;
      function isFunction2(input) {
        return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]";
      }
      function set2(config) {
        var prop, i2;
        for (i2 in config) {
          if (hasOwnProp(config, i2)) {
            prop = config[i2];
            if (isFunction2(prop)) {
              this[i2] = prop;
            } else {
              this["_" + i2] = prop;
            }
          }
        }
        this._config = config;
        this._dayOfMonthOrdinalParseLenient = new RegExp(
          (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source
        );
      }
      function mergeConfigs(parentConfig, childConfig) {
        var res = extend({}, parentConfig), prop;
        for (prop in childConfig) {
          if (hasOwnProp(childConfig, prop)) {
            if (isObject2(parentConfig[prop]) && isObject2(childConfig[prop])) {
              res[prop] = {};
              extend(res[prop], parentConfig[prop]);
              extend(res[prop], childConfig[prop]);
            } else if (childConfig[prop] != null) {
              res[prop] = childConfig[prop];
            } else {
              delete res[prop];
            }
          }
        }
        for (prop in parentConfig) {
          if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject2(parentConfig[prop])) {
            res[prop] = extend({}, res[prop]);
          }
        }
        return res;
      }
      function Locale(config) {
        if (config != null) {
          this.set(config);
        }
      }
      var keys;
      if (Object.keys) {
        keys = Object.keys;
      } else {
        keys = function(obj) {
          var i2, res = [];
          for (i2 in obj) {
            if (hasOwnProp(obj, i2)) {
              res.push(i2);
            }
          }
          return res;
        };
      }
      var defaultCalendar = {
        sameDay: "[Today at] LT",
        nextDay: "[Tomorrow at] LT",
        nextWeek: "dddd [at] LT",
        lastDay: "[Yesterday at] LT",
        lastWeek: "[Last] dddd [at] LT",
        sameElse: "L"
      };
      function calendar(key, mom, now3) {
        var output = this._calendar[key] || this._calendar["sameElse"];
        return isFunction2(output) ? output.call(mom, now3) : output;
      }
      function zeroFill(number, targetLength, forceSign) {
        var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign3 = number >= 0;
        return (sign3 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
      }
      var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
      function addFormatToken(token2, padded, ordinal2, callback2) {
        var func = callback2;
        if (typeof callback2 === "string") {
          func = function() {
            return this[callback2]();
          };
        }
        if (token2) {
          formatTokenFunctions[token2] = func;
        }
        if (padded) {
          formatTokenFunctions[padded[0]] = function() {
            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
          };
        }
        if (ordinal2) {
          formatTokenFunctions[ordinal2] = function() {
            return this.localeData().ordinal(
              func.apply(this, arguments),
              token2
            );
          };
        }
      }
      function removeFormattingTokens(input) {
        if (input.match(/\[[\s\S]/)) {
          return input.replace(/^\[|\]$/g, "");
        }
        return input.replace(/\\/g, "");
      }
      function makeFormatFunction(format2) {
        var array = format2.match(formattingTokens), i2, length;
        for (i2 = 0, length = array.length; i2 < length; i2++) {
          if (formatTokenFunctions[array[i2]]) {
            array[i2] = formatTokenFunctions[array[i2]];
          } else {
            array[i2] = removeFormattingTokens(array[i2]);
          }
        }
        return function(mom) {
          var output = "", i3;
          for (i3 = 0; i3 < length; i3++) {
            output += isFunction2(array[i3]) ? array[i3].call(mom, format2) : array[i3];
          }
          return output;
        };
      }
      function formatMoment(m2, format2) {
        if (!m2.isValid()) {
          return m2.localeData().invalidDate();
        }
        format2 = expandFormat(format2, m2.localeData());
        formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2);
        return formatFunctions[format2](m2);
      }
      function expandFormat(format2, locale2) {
        var i2 = 5;
        function replaceLongDateFormatTokens(input) {
          return locale2.longDateFormat(input) || input;
        }
        localFormattingTokens.lastIndex = 0;
        while (i2 >= 0 && localFormattingTokens.test(format2)) {
          format2 = format2.replace(
            localFormattingTokens,
            replaceLongDateFormatTokens
          );
          localFormattingTokens.lastIndex = 0;
          i2 -= 1;
        }
        return format2;
      }
      var defaultLongDateFormat = {
        LTS: "h:mm:ss A",
        LT: "h:mm A",
        L: "MM/DD/YYYY",
        LL: "MMMM D, YYYY",
        LLL: "MMMM D, YYYY h:mm A",
        LLLL: "dddd, MMMM D, YYYY h:mm A"
      };
      function longDateFormat(key) {
        var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
        if (format2 || !formatUpper) {
          return format2;
        }
        this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) {
          if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
            return tok.slice(1);
          }
          return tok;
        }).join("");
        return this._longDateFormat[key];
      }
      var defaultInvalidDate = "Invalid date";
      function invalidDate() {
        return this._invalidDate;
      }
      var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
      function ordinal(number) {
        return this._ordinal.replace("%d", number);
      }
      var defaultRelativeTime = {
        future: "in %s",
        past: "%s ago",
        s: "a few seconds",
        ss: "%d seconds",
        m: "a minute",
        mm: "%d minutes",
        h: "an hour",
        hh: "%d hours",
        d: "a day",
        dd: "%d days",
        w: "a week",
        ww: "%d weeks",
        M: "a month",
        MM: "%d months",
        y: "a year",
        yy: "%d years"
      };
      function relativeTime(number, withoutSuffix, string, isFuture) {
        var output = this._relativeTime[string];
        return isFunction2(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
      }
      function pastFuture(diff2, output) {
        var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
        return isFunction2(format2) ? format2(output) : format2.replace(/%s/i, output);
      }
      var aliases = {
        D: "date",
        dates: "date",
        date: "date",
        d: "day",
        days: "day",
        day: "day",
        e: "weekday",
        weekdays: "weekday",
        weekday: "weekday",
        E: "isoWeekday",
        isoweekdays: "isoWeekday",
        isoweekday: "isoWeekday",
        DDD: "dayOfYear",
        dayofyears: "dayOfYear",
        dayofyear: "dayOfYear",
        h: "hour",
        hours: "hour",
        hour: "hour",
        ms: "millisecond",
        milliseconds: "millisecond",
        millisecond: "millisecond",
        m: "minute",
        minutes: "minute",
        minute: "minute",
        M: "month",
        months: "month",
        month: "month",
        Q: "quarter",
        quarters: "quarter",
        quarter: "quarter",
        s: "second",
        seconds: "second",
        second: "second",
        gg: "weekYear",
        weekyears: "weekYear",
        weekyear: "weekYear",
        GG: "isoWeekYear",
        isoweekyears: "isoWeekYear",
        isoweekyear: "isoWeekYear",
        w: "week",
        weeks: "week",
        week: "week",
        W: "isoWeek",
        isoweeks: "isoWeek",
        isoweek: "isoWeek",
        y: "year",
        years: "year",
        year: "year"
      };
      function normalizeUnits(units) {
        return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : void 0;
      }
      function normalizeObjectUnits(inputObject) {
        var normalizedInput = {}, normalizedProp, prop;
        for (prop in inputObject) {
          if (hasOwnProp(inputObject, prop)) {
            normalizedProp = normalizeUnits(prop);
            if (normalizedProp) {
              normalizedInput[normalizedProp] = inputObject[prop];
            }
          }
        }
        return normalizedInput;
      }
      var priorities = {
        date: 9,
        day: 11,
        weekday: 11,
        isoWeekday: 11,
        dayOfYear: 4,
        hour: 13,
        millisecond: 16,
        minute: 14,
        month: 8,
        quarter: 7,
        second: 15,
        weekYear: 1,
        isoWeekYear: 1,
        week: 5,
        isoWeek: 5,
        year: 1
      };
      function getPrioritizedUnits(unitsObj) {
        var units = [], u2;
        for (u2 in unitsObj) {
          if (hasOwnProp(unitsObj, u2)) {
            units.push({ unit: u2, priority: priorities[u2] });
          }
        }
        units.sort(function(a2, b2) {
          return a2.priority - b2.priority;
        });
        return units;
      }
      var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, match1to2NoLeadingZero = /^[1-9]\d?/, match1to2HasZero = /^([1-9]\d|\d)/, regexes;
      regexes = {};
      function addRegexToken(token2, regex, strictRegex) {
        regexes[token2] = isFunction2(regex) ? regex : function(isStrict, localeData2) {
          return isStrict && strictRegex ? strictRegex : regex;
        };
      }
      function getParseRegexForToken(token2, config) {
        if (!hasOwnProp(regexes, token2)) {
          return new RegExp(unescapeFormat(token2));
        }
        return regexes[token2](config._strict, config._locale);
      }
      function unescapeFormat(s2) {
        return regexEscape(
          s2.replace("\\", "").replace(
            /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
            function(matched, p1, p2, p3, p4) {
              return p1 || p2 || p3 || p4;
            }
          )
        );
      }
      function regexEscape(s2) {
        return s2.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
      }
      function absFloor(number) {
        if (number < 0) {
          return Math.ceil(number) || 0;
        } else {
          return Math.floor(number);
        }
      }
      function toInt(argumentForCoercion) {
        var coercedNumber = +argumentForCoercion, value = 0;
        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
          value = absFloor(coercedNumber);
        }
        return value;
      }
      var tokens = {};
      function addParseToken(token2, callback2) {
        var i2, func = callback2, tokenLen;
        if (typeof token2 === "string") {
          token2 = [token2];
        }
        if (isNumber2(callback2)) {
          func = function(input, array) {
            array[callback2] = toInt(input);
          };
        }
        tokenLen = token2.length;
        for (i2 = 0; i2 < tokenLen; i2++) {
          tokens[token2[i2]] = func;
        }
      }
      function addWeekParseToken(token2, callback2) {
        addParseToken(token2, function(input, array, config, token3) {
          config._w = config._w || {};
          callback2(input, config._w, config, token3);
        });
      }
      function addTimeToArrayFromToken(token2, input, config) {
        if (input != null && hasOwnProp(tokens, token2)) {
          tokens[token2](input, config._a, config, token2);
        }
      }
      function isLeapYear(year) {
        return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
      }
      var YEAR = 0, MONTH = 1, DATE = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6, WEEK = 7, WEEKDAY = 8;
      addFormatToken("Y", 0, 0, function() {
        var y2 = this.year();
        return y2 <= 9999 ? zeroFill(y2, 4) : "+" + y2;
      });
      addFormatToken(0, ["YY", 2], 0, function() {
        return this.year() % 100;
      });
      addFormatToken(0, ["YYYY", 4], 0, "year");
      addFormatToken(0, ["YYYYY", 5], 0, "year");
      addFormatToken(0, ["YYYYYY", 6, true], 0, "year");
      addRegexToken("Y", matchSigned);
      addRegexToken("YY", match1to2, match2);
      addRegexToken("YYYY", match1to4, match4);
      addRegexToken("YYYYY", match1to6, match6);
      addRegexToken("YYYYYY", match1to6, match6);
      addParseToken(["YYYYY", "YYYYYY"], YEAR);
      addParseToken("YYYY", function(input, array) {
        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
      });
      addParseToken("YY", function(input, array) {
        array[YEAR] = hooks.parseTwoDigitYear(input);
      });
      addParseToken("Y", function(input, array) {
        array[YEAR] = parseInt(input, 10);
      });
      function daysInYear(year) {
        return isLeapYear(year) ? 366 : 365;
      }
      hooks.parseTwoDigitYear = function(input) {
        return toInt(input) + (toInt(input) > 68 ? 1900 : 2e3);
      };
      var getSetYear = makeGetSet("FullYear", true);
      function getIsLeapYear() {
        return isLeapYear(this.year());
      }
      function makeGetSet(unit, keepTime) {
        return function(value) {
          if (value != null) {
            set$1(this, unit, value);
            hooks.updateOffset(this, keepTime);
            return this;
          } else {
            return get(this, unit);
          }
        };
      }
      function get(mom, unit) {
        if (!mom.isValid()) {
          return NaN;
        }
        var d2 = mom._d, isUTC = mom._isUTC;
        switch (unit) {
          case "Milliseconds":
            return isUTC ? d2.getUTCMilliseconds() : d2.getMilliseconds();
          case "Seconds":
            return isUTC ? d2.getUTCSeconds() : d2.getSeconds();
          case "Minutes":
            return isUTC ? d2.getUTCMinutes() : d2.getMinutes();
          case "Hours":
            return isUTC ? d2.getUTCHours() : d2.getHours();
          case "Date":
            return isUTC ? d2.getUTCDate() : d2.getDate();
          case "Day":
            return isUTC ? d2.getUTCDay() : d2.getDay();
          case "Month":
            return isUTC ? d2.getUTCMonth() : d2.getMonth();
          case "FullYear":
            return isUTC ? d2.getUTCFullYear() : d2.getFullYear();
          default:
            return NaN;
        }
      }
      function set$1(mom, unit, value) {
        var d2, isUTC, year, month, date;
        if (!mom.isValid() || isNaN(value)) {
          return;
        }
        d2 = mom._d;
        isUTC = mom._isUTC;
        switch (unit) {
          case "Milliseconds":
            return void (isUTC ? d2.setUTCMilliseconds(value) : d2.setMilliseconds(value));
          case "Seconds":
            return void (isUTC ? d2.setUTCSeconds(value) : d2.setSeconds(value));
          case "Minutes":
            return void (isUTC ? d2.setUTCMinutes(value) : d2.setMinutes(value));
          case "Hours":
            return void (isUTC ? d2.setUTCHours(value) : d2.setHours(value));
          case "Date":
            return void (isUTC ? d2.setUTCDate(value) : d2.setDate(value));
          // case 'Day': // Not real
          //    return void (isUTC ? d.setUTCDay(value) : d.setDay(value));
          // case 'Month': // Not used because we need to pass two variables
          //     return void (isUTC ? d.setUTCMonth(value) : d.setMonth(value));
          case "FullYear":
            break;
          // See below ...
          default:
            return;
        }
        year = value;
        month = mom.month();
        date = mom.date();
        date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
        void (isUTC ? d2.setUTCFullYear(year, month, date) : d2.setFullYear(year, month, date));
      }
      function stringGet(units) {
        units = normalizeUnits(units);
        if (isFunction2(this[units])) {
          return this[units]();
        }
        return this;
      }
      function stringSet(units, value) {
        if (typeof units === "object") {
          units = normalizeObjectUnits(units);
          var prioritized = getPrioritizedUnits(units), i2, prioritizedLen = prioritized.length;
          for (i2 = 0; i2 < prioritizedLen; i2++) {
            this[prioritized[i2].unit](units[prioritized[i2].unit]);
          }
        } else {
          units = normalizeUnits(units);
          if (isFunction2(this[units])) {
            return this[units](value);
          }
        }
        return this;
      }
      function mod(n2, x2) {
        return (n2 % x2 + x2) % x2;
      }
      var indexOf;
      if (Array.prototype.indexOf) {
        indexOf = Array.prototype.indexOf;
      } else {
        indexOf = function(o2) {
          var i2;
          for (i2 = 0; i2 < this.length; ++i2) {
            if (this[i2] === o2) {
              return i2;
            }
          }
          return -1;
        };
      }
      function daysInMonth(year, month) {
        if (isNaN(year) || isNaN(month)) {
          return NaN;
        }
        var modMonth = mod(month, 12);
        year += (month - modMonth) / 12;
        return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;
      }
      addFormatToken("M", ["MM", 2], "Mo", function() {
        return this.month() + 1;
      });
      addFormatToken("MMM", 0, 0, function(format2) {
        return this.localeData().monthsShort(this, format2);
      });
      addFormatToken("MMMM", 0, 0, function(format2) {
        return this.localeData().months(this, format2);
      });
      addRegexToken("M", match1to2, match1to2NoLeadingZero);
      addRegexToken("MM", match1to2, match2);
      addRegexToken("MMM", function(isStrict, locale2) {
        return locale2.monthsShortRegex(isStrict);
      });
      addRegexToken("MMMM", function(isStrict, locale2) {
        return locale2.monthsRegex(isStrict);
      });
      addParseToken(["M", "MM"], function(input, array) {
        array[MONTH] = toInt(input) - 1;
      });
      addParseToken(["MMM", "MMMM"], function(input, array, config, token2) {
        var month = config._locale.monthsParse(input, token2, config._strict);
        if (month != null) {
          array[MONTH] = month;
        } else {
          getParsingFlags(config).invalidMonth = input;
        }
      });
      var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split(
        "_"
      ), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
      function localeMonths(m2, format2) {
        if (!m2) {
          return isArray2(this._months) ? this._months : this._months["standalone"];
        }
        return isArray2(this._months) ? this._months[m2.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m2.month()];
      }
      function localeMonthsShort(m2, format2) {
        if (!m2) {
          return isArray2(this._monthsShort) ? this._monthsShort : this._monthsShort["standalone"];
        }
        return isArray2(this._monthsShort) ? this._monthsShort[m2.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m2.month()];
      }
      function handleStrictParse(monthName, format2, strict) {
        var i2, ii, mom, llc = monthName.toLocaleLowerCase();
        if (!this._monthsParse) {
          this._monthsParse = [];
          this._longMonthsParse = [];
          this._shortMonthsParse = [];
          for (i2 = 0; i2 < 12; ++i2) {
            mom = createUTC([2e3, i2]);
            this._shortMonthsParse[i2] = this.monthsShort(
              mom,
              ""
            ).toLocaleLowerCase();
            this._longMonthsParse[i2] = this.months(mom, "").toLocaleLowerCase();
          }
        }
        if (strict) {
          if (format2 === "MMM") {
            ii = indexOf.call(this._shortMonthsParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._longMonthsParse, llc);
            return ii !== -1 ? ii : null;
          }
        } else {
          if (format2 === "MMM") {
            ii = indexOf.call(this._shortMonthsParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._longMonthsParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._longMonthsParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._shortMonthsParse, llc);
            return ii !== -1 ? ii : null;
          }
        }
      }
      function localeMonthsParse(monthName, format2, strict) {
        var i2, mom, regex;
        if (this._monthsParseExact) {
          return handleStrictParse.call(this, monthName, format2, strict);
        }
        if (!this._monthsParse) {
          this._monthsParse = [];
          this._longMonthsParse = [];
          this._shortMonthsParse = [];
        }
        for (i2 = 0; i2 < 12; i2++) {
          mom = createUTC([2e3, i2]);
          if (strict && !this._longMonthsParse[i2]) {
            this._longMonthsParse[i2] = new RegExp(
              "^" + this.months(mom, "").replace(".", "") + "$",
              "i"
            );
            this._shortMonthsParse[i2] = new RegExp(
              "^" + this.monthsShort(mom, "").replace(".", "") + "$",
              "i"
            );
          }
          if (!strict && !this._monthsParse[i2]) {
            regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, "");
            this._monthsParse[i2] = new RegExp(regex.replace(".", ""), "i");
          }
          if (strict && format2 === "MMMM" && this._longMonthsParse[i2].test(monthName)) {
            return i2;
          } else if (strict && format2 === "MMM" && this._shortMonthsParse[i2].test(monthName)) {
            return i2;
          } else if (!strict && this._monthsParse[i2].test(monthName)) {
            return i2;
          }
        }
      }
      function setMonth(mom, value) {
        if (!mom.isValid()) {
          return mom;
        }
        if (typeof value === "string") {
          if (/^\d+$/.test(value)) {
            value = toInt(value);
          } else {
            value = mom.localeData().monthsParse(value);
            if (!isNumber2(value)) {
              return mom;
            }
          }
        }
        var month = value, date = mom.date();
        date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
        void (mom._isUTC ? mom._d.setUTCMonth(month, date) : mom._d.setMonth(month, date));
        return mom;
      }
      function getSetMonth(value) {
        if (value != null) {
          setMonth(this, value);
          hooks.updateOffset(this, true);
          return this;
        } else {
          return get(this, "Month");
        }
      }
      function getDaysInMonth() {
        return daysInMonth(this.year(), this.month());
      }
      function monthsShortRegex(isStrict) {
        if (this._monthsParseExact) {
          if (!hasOwnProp(this, "_monthsRegex")) {
            computeMonthsParse.call(this);
          }
          if (isStrict) {
            return this._monthsShortStrictRegex;
          } else {
            return this._monthsShortRegex;
          }
        } else {
          if (!hasOwnProp(this, "_monthsShortRegex")) {
            this._monthsShortRegex = defaultMonthsShortRegex;
          }
          return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;
        }
      }
      function monthsRegex(isStrict) {
        if (this._monthsParseExact) {
          if (!hasOwnProp(this, "_monthsRegex")) {
            computeMonthsParse.call(this);
          }
          if (isStrict) {
            return this._monthsStrictRegex;
          } else {
            return this._monthsRegex;
          }
        } else {
          if (!hasOwnProp(this, "_monthsRegex")) {
            this._monthsRegex = defaultMonthsRegex;
          }
          return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;
        }
      }
      function computeMonthsParse() {
        function cmpLenRev(a2, b2) {
          return b2.length - a2.length;
        }
        var shortPieces = [], longPieces = [], mixedPieces = [], i2, mom, shortP, longP;
        for (i2 = 0; i2 < 12; i2++) {
          mom = createUTC([2e3, i2]);
          shortP = regexEscape(this.monthsShort(mom, ""));
          longP = regexEscape(this.months(mom, ""));
          shortPieces.push(shortP);
          longPieces.push(longP);
          mixedPieces.push(longP);
          mixedPieces.push(shortP);
        }
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
        this._monthsShortRegex = this._monthsRegex;
        this._monthsStrictRegex = new RegExp(
          "^(" + longPieces.join("|") + ")",
          "i"
        );
        this._monthsShortStrictRegex = new RegExp(
          "^(" + shortPieces.join("|") + ")",
          "i"
        );
      }
      function createDate(y2, m2, d2, h3, M2, s2, ms) {
        var date;
        if (y2 < 100 && y2 >= 0) {
          date = new Date(y2 + 400, m2, d2, h3, M2, s2, ms);
          if (isFinite(date.getFullYear())) {
            date.setFullYear(y2);
          }
        } else {
          date = new Date(y2, m2, d2, h3, M2, s2, ms);
        }
        return date;
      }
      function createUTCDate(y2) {
        var date, args;
        if (y2 < 100 && y2 >= 0) {
          args = Array.prototype.slice.call(arguments);
          args[0] = y2 + 400;
          date = new Date(Date.UTC.apply(null, args));
          if (isFinite(date.getUTCFullYear())) {
            date.setUTCFullYear(y2);
          }
        } else {
          date = new Date(Date.UTC.apply(null, arguments));
        }
        return date;
      }
      function firstWeekOffset(year, dow, doy) {
        var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
        return -fwdlw + fwd - 1;
      }
      function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
        var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
        if (dayOfYear <= 0) {
          resYear = year - 1;
          resDayOfYear = daysInYear(resYear) + dayOfYear;
        } else if (dayOfYear > daysInYear(year)) {
          resYear = year + 1;
          resDayOfYear = dayOfYear - daysInYear(year);
        } else {
          resYear = year;
          resDayOfYear = dayOfYear;
        }
        return {
          year: resYear,
          dayOfYear: resDayOfYear
        };
      }
      function weekOfYear(mom, dow, doy) {
        var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
        if (week < 1) {
          resYear = mom.year() - 1;
          resWeek = week + weeksInYear(resYear, dow, doy);
        } else if (week > weeksInYear(mom.year(), dow, doy)) {
          resWeek = week - weeksInYear(mom.year(), dow, doy);
          resYear = mom.year() + 1;
        } else {
          resYear = mom.year();
          resWeek = week;
        }
        return {
          week: resWeek,
          year: resYear
        };
      }
      function weeksInYear(year, dow, doy) {
        var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
      }
      addFormatToken("w", ["ww", 2], "wo", "week");
      addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
      addRegexToken("w", match1to2, match1to2NoLeadingZero);
      addRegexToken("ww", match1to2, match2);
      addRegexToken("W", match1to2, match1to2NoLeadingZero);
      addRegexToken("WW", match1to2, match2);
      addWeekParseToken(
        ["w", "ww", "W", "WW"],
        function(input, week, config, token2) {
          week[token2.substr(0, 1)] = toInt(input);
        }
      );
      function localeWeek(mom) {
        return weekOfYear(mom, this._week.dow, this._week.doy).week;
      }
      var defaultLocaleWeek = {
        dow: 0,
        // Sunday is the first day of the week.
        doy: 6
        // The week that contains Jan 6th is the first week of the year.
      };
      function localeFirstDayOfWeek() {
        return this._week.dow;
      }
      function localeFirstDayOfYear() {
        return this._week.doy;
      }
      function getSetWeek(input) {
        var week = this.localeData().week(this);
        return input == null ? week : this.add((input - week) * 7, "d");
      }
      function getSetISOWeek(input) {
        var week = weekOfYear(this, 1, 4).week;
        return input == null ? week : this.add((input - week) * 7, "d");
      }
      addFormatToken("d", 0, "do", "day");
      addFormatToken("dd", 0, 0, function(format2) {
        return this.localeData().weekdaysMin(this, format2);
      });
      addFormatToken("ddd", 0, 0, function(format2) {
        return this.localeData().weekdaysShort(this, format2);
      });
      addFormatToken("dddd", 0, 0, function(format2) {
        return this.localeData().weekdays(this, format2);
      });
      addFormatToken("e", 0, 0, "weekday");
      addFormatToken("E", 0, 0, "isoWeekday");
      addRegexToken("d", match1to2);
      addRegexToken("e", match1to2);
      addRegexToken("E", match1to2);
      addRegexToken("dd", function(isStrict, locale2) {
        return locale2.weekdaysMinRegex(isStrict);
      });
      addRegexToken("ddd", function(isStrict, locale2) {
        return locale2.weekdaysShortRegex(isStrict);
      });
      addRegexToken("dddd", function(isStrict, locale2) {
        return locale2.weekdaysRegex(isStrict);
      });
      addWeekParseToken(["dd", "ddd", "dddd"], function(input, week, config, token2) {
        var weekday = config._locale.weekdaysParse(input, token2, config._strict);
        if (weekday != null) {
          week.d = weekday;
        } else {
          getParsingFlags(config).invalidWeekday = input;
        }
      });
      addWeekParseToken(["d", "e", "E"], function(input, week, config, token2) {
        week[token2] = toInt(input);
      });
      function parseWeekday(input, locale2) {
        if (typeof input !== "string") {
          return input;
        }
        if (!isNaN(input)) {
          return parseInt(input, 10);
        }
        input = locale2.weekdaysParse(input);
        if (typeof input === "number") {
          return input;
        }
        return null;
      }
      function parseIsoWeekday(input, locale2) {
        if (typeof input === "string") {
          return locale2.weekdaysParse(input) % 7 || 7;
        }
        return isNaN(input) ? null : input;
      }
      function shiftWeekdays(ws, n2) {
        return ws.slice(n2, 7).concat(ws.slice(0, n2));
      }
      var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
      function localeWeekdays(m2, format2) {
        var weekdays = isArray2(this._weekdays) ? this._weekdays : this._weekdays[m2 && m2 !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"];
        return m2 === true ? shiftWeekdays(weekdays, this._week.dow) : m2 ? weekdays[m2.day()] : weekdays;
      }
      function localeWeekdaysShort(m2) {
        return m2 === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m2 ? this._weekdaysShort[m2.day()] : this._weekdaysShort;
      }
      function localeWeekdaysMin(m2) {
        return m2 === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m2 ? this._weekdaysMin[m2.day()] : this._weekdaysMin;
      }
      function handleStrictParse$1(weekdayName, format2, strict) {
        var i2, ii, mom, llc = weekdayName.toLocaleLowerCase();
        if (!this._weekdaysParse) {
          this._weekdaysParse = [];
          this._shortWeekdaysParse = [];
          this._minWeekdaysParse = [];
          for (i2 = 0; i2 < 7; ++i2) {
            mom = createUTC([2e3, 1]).day(i2);
            this._minWeekdaysParse[i2] = this.weekdaysMin(
              mom,
              ""
            ).toLocaleLowerCase();
            this._shortWeekdaysParse[i2] = this.weekdaysShort(
              mom,
              ""
            ).toLocaleLowerCase();
            this._weekdaysParse[i2] = this.weekdays(mom, "").toLocaleLowerCase();
          }
        }
        if (strict) {
          if (format2 === "dddd") {
            ii = indexOf.call(this._weekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else if (format2 === "ddd") {
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._minWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          }
        } else {
          if (format2 === "dddd") {
            ii = indexOf.call(this._weekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._minWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else if (format2 === "ddd") {
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._weekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._minWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._minWeekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._weekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          }
        }
      }
      function localeWeekdaysParse(weekdayName, format2, strict) {
        var i2, mom, regex;
        if (this._weekdaysParseExact) {
          return handleStrictParse$1.call(this, weekdayName, format2, strict);
        }
        if (!this._weekdaysParse) {
          this._weekdaysParse = [];
          this._minWeekdaysParse = [];
          this._shortWeekdaysParse = [];
          this._fullWeekdaysParse = [];
        }
        for (i2 = 0; i2 < 7; i2++) {
          mom = createUTC([2e3, 1]).day(i2);
          if (strict && !this._fullWeekdaysParse[i2]) {
            this._fullWeekdaysParse[i2] = new RegExp(
              "^" + this.weekdays(mom, "").replace(".", "\\.?") + "$",
              "i"
            );
            this._shortWeekdaysParse[i2] = new RegExp(
              "^" + this.weekdaysShort(mom, "").replace(".", "\\.?") + "$",
              "i"
            );
            this._minWeekdaysParse[i2] = new RegExp(
              "^" + this.weekdaysMin(mom, "").replace(".", "\\.?") + "$",
              "i"
            );
          }
          if (!this._weekdaysParse[i2]) {
            regex = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, "");
            this._weekdaysParse[i2] = new RegExp(regex.replace(".", ""), "i");
          }
          if (strict && format2 === "dddd" && this._fullWeekdaysParse[i2].test(weekdayName)) {
            return i2;
          } else if (strict && format2 === "ddd" && this._shortWeekdaysParse[i2].test(weekdayName)) {
            return i2;
          } else if (strict && format2 === "dd" && this._minWeekdaysParse[i2].test(weekdayName)) {
            return i2;
          } else if (!strict && this._weekdaysParse[i2].test(weekdayName)) {
            return i2;
          }
        }
      }
      function getSetDayOfWeek(input) {
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        var day = get(this, "Day");
        if (input != null) {
          input = parseWeekday(input, this.localeData());
          return this.add(input - day, "d");
        } else {
          return day;
        }
      }
      function getSetLocaleDayOfWeek(input) {
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
        return input == null ? weekday : this.add(input - weekday, "d");
      }
      function getSetISODayOfWeek(input) {
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        if (input != null) {
          var weekday = parseIsoWeekday(input, this.localeData());
          return this.day(this.day() % 7 ? weekday : weekday - 7);
        } else {
          return this.day() || 7;
        }
      }
      function weekdaysRegex(isStrict) {
        if (this._weekdaysParseExact) {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            computeWeekdaysParse.call(this);
          }
          if (isStrict) {
            return this._weekdaysStrictRegex;
          } else {
            return this._weekdaysRegex;
          }
        } else {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            this._weekdaysRegex = defaultWeekdaysRegex;
          }
          return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
        }
      }
      function weekdaysShortRegex(isStrict) {
        if (this._weekdaysParseExact) {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            computeWeekdaysParse.call(this);
          }
          if (isStrict) {
            return this._weekdaysShortStrictRegex;
          } else {
            return this._weekdaysShortRegex;
          }
        } else {
          if (!hasOwnProp(this, "_weekdaysShortRegex")) {
            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
          }
          return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
        }
      }
      function weekdaysMinRegex(isStrict) {
        if (this._weekdaysParseExact) {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            computeWeekdaysParse.call(this);
          }
          if (isStrict) {
            return this._weekdaysMinStrictRegex;
          } else {
            return this._weekdaysMinRegex;
          }
        } else {
          if (!hasOwnProp(this, "_weekdaysMinRegex")) {
            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
          }
          return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
        }
      }
      function computeWeekdaysParse() {
        function cmpLenRev(a2, b2) {
          return b2.length - a2.length;
        }
        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i2, mom, minp, shortp, longp;
        for (i2 = 0; i2 < 7; i2++) {
          mom = createUTC([2e3, 1]).day(i2);
          minp = regexEscape(this.weekdaysMin(mom, ""));
          shortp = regexEscape(this.weekdaysShort(mom, ""));
          longp = regexEscape(this.weekdays(mom, ""));
          minPieces.push(minp);
          shortPieces.push(shortp);
          longPieces.push(longp);
          mixedPieces.push(minp);
          mixedPieces.push(shortp);
          mixedPieces.push(longp);
        }
        minPieces.sort(cmpLenRev);
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
        this._weekdaysShortRegex = this._weekdaysRegex;
        this._weekdaysMinRegex = this._weekdaysRegex;
        this._weekdaysStrictRegex = new RegExp(
          "^(" + longPieces.join("|") + ")",
          "i"
        );
        this._weekdaysShortStrictRegex = new RegExp(
          "^(" + shortPieces.join("|") + ")",
          "i"
        );
        this._weekdaysMinStrictRegex = new RegExp(
          "^(" + minPieces.join("|") + ")",
          "i"
        );
      }
      function hFormat() {
        return this.hours() % 12 || 12;
      }
      function kFormat() {
        return this.hours() || 24;
      }
      addFormatToken("H", ["HH", 2], 0, "hour");
      addFormatToken("h", ["hh", 2], 0, hFormat);
      addFormatToken("k", ["kk", 2], 0, kFormat);
      addFormatToken("hmm", 0, 0, function() {
        return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2);
      });
      addFormatToken("hmmss", 0, 0, function() {
        return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
      });
      addFormatToken("Hmm", 0, 0, function() {
        return "" + this.hours() + zeroFill(this.minutes(), 2);
      });
      addFormatToken("Hmmss", 0, 0, function() {
        return "" + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
      });
      function meridiem(token2, lowercase) {
        addFormatToken(token2, 0, 0, function() {
          return this.localeData().meridiem(
            this.hours(),
            this.minutes(),
            lowercase
          );
        });
      }
      meridiem("a", true);
      meridiem("A", false);
      function matchMeridiem(isStrict, locale2) {
        return locale2._meridiemParse;
      }
      addRegexToken("a", matchMeridiem);
      addRegexToken("A", matchMeridiem);
      addRegexToken("H", match1to2, match1to2HasZero);
      addRegexToken("h", match1to2, match1to2NoLeadingZero);
      addRegexToken("k", match1to2, match1to2NoLeadingZero);
      addRegexToken("HH", match1to2, match2);
      addRegexToken("hh", match1to2, match2);
      addRegexToken("kk", match1to2, match2);
      addRegexToken("hmm", match3to4);
      addRegexToken("hmmss", match5to6);
      addRegexToken("Hmm", match3to4);
      addRegexToken("Hmmss", match5to6);
      addParseToken(["H", "HH"], HOUR);
      addParseToken(["k", "kk"], function(input, array, config) {
        var kInput = toInt(input);
        array[HOUR] = kInput === 24 ? 0 : kInput;
      });
      addParseToken(["a", "A"], function(input, array, config) {
        config._isPm = config._locale.isPM(input);
        config._meridiem = input;
      });
      addParseToken(["h", "hh"], function(input, array, config) {
        array[HOUR] = toInt(input);
        getParsingFlags(config).bigHour = true;
      });
      addParseToken("hmm", function(input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
        getParsingFlags(config).bigHour = true;
      });
      addParseToken("hmmss", function(input, array, config) {
        var pos1 = input.length - 4, pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
        getParsingFlags(config).bigHour = true;
      });
      addParseToken("Hmm", function(input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
      });
      addParseToken("Hmmss", function(input, array, config) {
        var pos1 = input.length - 4, pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
      });
      function localeIsPM(input) {
        return (input + "").toLowerCase().charAt(0) === "p";
      }
      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, getSetHour = makeGetSet("Hours", true);
      function localeMeridiem(hours2, minutes2, isLower) {
        if (hours2 > 11) {
          return isLower ? "pm" : "PM";
        } else {
          return isLower ? "am" : "AM";
        }
      }
      var baseConfig = {
        calendar: defaultCalendar,
        longDateFormat: defaultLongDateFormat,
        invalidDate: defaultInvalidDate,
        ordinal: defaultOrdinal,
        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
        relativeTime: defaultRelativeTime,
        months: defaultLocaleMonths,
        monthsShort: defaultLocaleMonthsShort,
        week: defaultLocaleWeek,
        weekdays: defaultLocaleWeekdays,
        weekdaysMin: defaultLocaleWeekdaysMin,
        weekdaysShort: defaultLocaleWeekdaysShort,
        meridiemParse: defaultLocaleMeridiemParse
      };
      var locales = {}, localeFamilies = {}, globalLocale;
      function commonPrefix(arr1, arr2) {
        var i2, minl = Math.min(arr1.length, arr2.length);
        for (i2 = 0; i2 < minl; i2 += 1) {
          if (arr1[i2] !== arr2[i2]) {
            return i2;
          }
        }
        return minl;
      }
      function normalizeLocale(key) {
        return key ? key.toLowerCase().replace("_", "-") : key;
      }
      function chooseLocale(names2) {
        var i2 = 0, j2, next, locale2, split;
        while (i2 < names2.length) {
          split = normalizeLocale(names2[i2]).split("-");
          j2 = split.length;
          next = normalizeLocale(names2[i2 + 1]);
          next = next ? next.split("-") : null;
          while (j2 > 0) {
            locale2 = loadLocale(split.slice(0, j2).join("-"));
            if (locale2) {
              return locale2;
            }
            if (next && next.length >= j2 && commonPrefix(split, next) >= j2 - 1) {
              break;
            }
            j2--;
          }
          i2++;
        }
        return globalLocale;
      }
      function isLocaleNameSane(name) {
        return !!(name && name.match("^[^/\\\\]*$"));
      }
      function loadLocale(name) {
        var oldLocale = null, aliasedRequire;
        if (locales[name] === void 0 && typeof module2 !== "undefined" && module2 && module2.exports && isLocaleNameSane(name)) {
          try {
            oldLocale = globalLocale._abbr;
            aliasedRequire = require;
            aliasedRequire("./locale/" + name);
            getSetGlobalLocale(oldLocale);
          } catch (e2) {
            locales[name] = null;
          }
        }
        return locales[name];
      }
      function getSetGlobalLocale(key, values) {
        var data;
        if (key) {
          if (isUndefined(values)) {
            data = getLocale(key);
          } else {
            data = defineLocale(key, values);
          }
          if (data) {
            globalLocale = data;
          } else {
            if (typeof console !== "undefined" && console.warn) {
              console.warn(
                "Locale " + key + " not found. Did you forget to load it?"
              );
            }
          }
        }
        return globalLocale._abbr;
      }
      function defineLocale(name, config) {
        if (config !== null) {
          var locale2, parentConfig = baseConfig;
          config.abbr = name;
          if (locales[name] != null) {
            deprecateSimple(
              "defineLocaleOverride",
              "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."
            );
            parentConfig = locales[name]._config;
          } else if (config.parentLocale != null) {
            if (locales[config.parentLocale] != null) {
              parentConfig = locales[config.parentLocale]._config;
            } else {
              locale2 = loadLocale(config.parentLocale);
              if (locale2 != null) {
                parentConfig = locale2._config;
              } else {
                if (!localeFamilies[config.parentLocale]) {
                  localeFamilies[config.parentLocale] = [];
                }
                localeFamilies[config.parentLocale].push({
                  name,
                  config
                });
                return null;
              }
            }
          }
          locales[name] = new Locale(mergeConfigs(parentConfig, config));
          if (localeFamilies[name]) {
            localeFamilies[name].forEach(function(x2) {
              defineLocale(x2.name, x2.config);
            });
          }
          getSetGlobalLocale(name);
          return locales[name];
        } else {
          delete locales[name];
          return null;
        }
      }
      function updateLocale(name, config) {
        if (config != null) {
          var locale2, tmpLocale, parentConfig = baseConfig;
          if (locales[name] != null && locales[name].parentLocale != null) {
            locales[name].set(mergeConfigs(locales[name]._config, config));
          } else {
            tmpLocale = loadLocale(name);
            if (tmpLocale != null) {
              parentConfig = tmpLocale._config;
            }
            config = mergeConfigs(parentConfig, config);
            if (tmpLocale == null) {
              config.abbr = name;
            }
            locale2 = new Locale(config);
            locale2.parentLocale = locales[name];
            locales[name] = locale2;
          }
          getSetGlobalLocale(name);
        } else {
          if (locales[name] != null) {
            if (locales[name].parentLocale != null) {
              locales[name] = locales[name].parentLocale;
              if (name === getSetGlobalLocale()) {
                getSetGlobalLocale(name);
              }
            } else if (locales[name] != null) {
              delete locales[name];
            }
          }
        }
        return locales[name];
      }
      function getLocale(key) {
        var locale2;
        if (key && key._locale && key._locale._abbr) {
          key = key._locale._abbr;
        }
        if (!key) {
          return globalLocale;
        }
        if (!isArray2(key)) {
          locale2 = loadLocale(key);
          if (locale2) {
            return locale2;
          }
          key = [key];
        }
        return chooseLocale(key);
      }
      function listLocales() {
        return keys(locales);
      }
      function checkOverflow(m2) {
        var overflow, a2 = m2._a;
        if (a2 && getParsingFlags(m2).overflow === -2) {
          overflow = a2[MONTH] < 0 || a2[MONTH] > 11 ? MONTH : a2[DATE] < 1 || a2[DATE] > daysInMonth(a2[YEAR], a2[MONTH]) ? DATE : a2[HOUR] < 0 || a2[HOUR] > 24 || a2[HOUR] === 24 && (a2[MINUTE] !== 0 || a2[SECOND] !== 0 || a2[MILLISECOND] !== 0) ? HOUR : a2[MINUTE] < 0 || a2[MINUTE] > 59 ? MINUTE : a2[SECOND] < 0 || a2[SECOND] > 59 ? SECOND : a2[MILLISECOND] < 0 || a2[MILLISECOND] > 999 ? MILLISECOND : -1;
          if (getParsingFlags(m2)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
            overflow = DATE;
          }
          if (getParsingFlags(m2)._overflowWeeks && overflow === -1) {
            overflow = WEEK;
          }
          if (getParsingFlags(m2)._overflowWeekday && overflow === -1) {
            overflow = WEEKDAY;
          }
          getParsingFlags(m2).overflow = overflow;
        }
        return m2;
      }
      var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, isoDates = [
        ["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/],
        ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/],
        ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/],
        ["GGGG-[W]WW", /\d{4}-W\d\d/, false],
        ["YYYY-DDD", /\d{4}-\d{3}/],
        ["YYYY-MM", /\d{4}-\d\d/, false],
        ["YYYYYYMMDD", /[+-]\d{10}/],
        ["YYYYMMDD", /\d{8}/],
        ["GGGG[W]WWE", /\d{4}W\d{3}/],
        ["GGGG[W]WW", /\d{4}W\d{2}/, false],
        ["YYYYDDD", /\d{7}/],
        ["YYYYMM", /\d{6}/, false],
        ["YYYY", /\d{4}/, false]
      ], isoTimes = [
        ["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/],
        ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/],
        ["HH:mm:ss", /\d\d:\d\d:\d\d/],
        ["HH:mm", /\d\d:\d\d/],
        ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/],
        ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/],
        ["HHmmss", /\d\d\d\d\d\d/],
        ["HHmm", /\d\d\d\d/],
        ["HH", /\d\d/]
      ], aspNetJsonRegex = /^\/?Date\((-?\d+)/i, rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/, obsOffsets = {
        UT: 0,
        GMT: 0,
        EDT: -4 * 60,
        EST: -5 * 60,
        CDT: -5 * 60,
        CST: -6 * 60,
        MDT: -6 * 60,
        MST: -7 * 60,
        PDT: -7 * 60,
        PST: -8 * 60
      };
      function configFromISO(config) {
        var i2, l2, string = config._i, match5 = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length;
        if (match5) {
          getParsingFlags(config).iso = true;
          for (i2 = 0, l2 = isoDatesLen; i2 < l2; i2++) {
            if (isoDates[i2][1].exec(match5[1])) {
              dateFormat = isoDates[i2][0];
              allowTime = isoDates[i2][2] !== false;
              break;
            }
          }
          if (dateFormat == null) {
            config._isValid = false;
            return;
          }
          if (match5[3]) {
            for (i2 = 0, l2 = isoTimesLen; i2 < l2; i2++) {
              if (isoTimes[i2][1].exec(match5[3])) {
                timeFormat = (match5[2] || " ") + isoTimes[i2][0];
                break;
              }
            }
            if (timeFormat == null) {
              config._isValid = false;
              return;
            }
          }
          if (!allowTime && timeFormat != null) {
            config._isValid = false;
            return;
          }
          if (match5[4]) {
            if (tzRegex.exec(match5[4])) {
              tzFormat = "Z";
            } else {
              config._isValid = false;
              return;
            }
          }
          config._f = dateFormat + (timeFormat || "") + (tzFormat || "");
          configFromStringAndFormat(config);
        } else {
          config._isValid = false;
        }
      }
      function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
        var result = [
          untruncateYear(yearStr),
          defaultLocaleMonthsShort.indexOf(monthStr),
          parseInt(dayStr, 10),
          parseInt(hourStr, 10),
          parseInt(minuteStr, 10)
        ];
        if (secondStr) {
          result.push(parseInt(secondStr, 10));
        }
        return result;
      }
      function untruncateYear(yearStr) {
        var year = parseInt(yearStr, 10);
        if (year <= 49) {
          return 2e3 + year;
        } else if (year <= 999) {
          return 1900 + year;
        }
        return year;
      }
      function preprocessRFC2822(s2) {
        return s2.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
      }
      function checkWeekday(weekdayStr, parsedInput, config) {
        if (weekdayStr) {
          var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), weekdayActual = new Date(
            parsedInput[0],
            parsedInput[1],
            parsedInput[2]
          ).getDay();
          if (weekdayProvided !== weekdayActual) {
            getParsingFlags(config).weekdayMismatch = true;
            config._isValid = false;
            return false;
          }
        }
        return true;
      }
      function calculateOffset(obsOffset, militaryOffset, numOffset) {
        if (obsOffset) {
          return obsOffsets[obsOffset];
        } else if (militaryOffset) {
          return 0;
        } else {
          var hm = parseInt(numOffset, 10), m2 = hm % 100, h3 = (hm - m2) / 100;
          return h3 * 60 + m2;
        }
      }
      function configFromRFC2822(config) {
        var match5 = rfc2822.exec(preprocessRFC2822(config._i)), parsedArray;
        if (match5) {
          parsedArray = extractFromRFC2822Strings(
            match5[4],
            match5[3],
            match5[2],
            match5[5],
            match5[6],
            match5[7]
          );
          if (!checkWeekday(match5[1], parsedArray, config)) {
            return;
          }
          config._a = parsedArray;
          config._tzm = calculateOffset(match5[8], match5[9], match5[10]);
          config._d = createUTCDate.apply(null, config._a);
          config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
          getParsingFlags(config).rfc2822 = true;
        } else {
          config._isValid = false;
        }
      }
      function configFromString(config) {
        var matched = aspNetJsonRegex.exec(config._i);
        if (matched !== null) {
          config._d = /* @__PURE__ */ new Date(+matched[1]);
          return;
        }
        configFromISO(config);
        if (config._isValid === false) {
          delete config._isValid;
        } else {
          return;
        }
        configFromRFC2822(config);
        if (config._isValid === false) {
          delete config._isValid;
        } else {
          return;
        }
        if (config._strict) {
          config._isValid = false;
        } else {
          hooks.createFromInputFallback(config);
        }
      }
      hooks.createFromInputFallback = deprecate(
        "value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",
        function(config) {
          config._d = /* @__PURE__ */ new Date(config._i + (config._useUTC ? " UTC" : ""));
        }
      );
      function defaults3(a2, b2, c2) {
        if (a2 != null) {
          return a2;
        }
        if (b2 != null) {
          return b2;
        }
        return c2;
      }
      function currentDateArray(config) {
        var nowValue = new Date(hooks.now());
        if (config._useUTC) {
          return [
            nowValue.getUTCFullYear(),
            nowValue.getUTCMonth(),
            nowValue.getUTCDate()
          ];
        }
        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
      }
      function configFromArray(config) {
        var i2, date, input = [], currentDate, expectedWeekday, yearToUse;
        if (config._d) {
          return;
        }
        currentDate = currentDateArray(config);
        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
          dayOfYearFromWeekInfo(config);
        }
        if (config._dayOfYear != null) {
          yearToUse = defaults3(config._a[YEAR], currentDate[YEAR]);
          if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
            getParsingFlags(config)._overflowDayOfYear = true;
          }
          date = createUTCDate(yearToUse, 0, config._dayOfYear);
          config._a[MONTH] = date.getUTCMonth();
          config._a[DATE] = date.getUTCDate();
        }
        for (i2 = 0; i2 < 3 && config._a[i2] == null; ++i2) {
          config._a[i2] = input[i2] = currentDate[i2];
        }
        for (; i2 < 7; i2++) {
          config._a[i2] = input[i2] = config._a[i2] == null ? i2 === 2 ? 1 : 0 : config._a[i2];
        }
        if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
          config._nextDay = true;
          config._a[HOUR] = 0;
        }
        config._d = (config._useUTC ? createUTCDate : createDate).apply(
          null,
          input
        );
        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
        if (config._tzm != null) {
          config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
        }
        if (config._nextDay) {
          config._a[HOUR] = 24;
        }
        if (config._w && typeof config._w.d !== "undefined" && config._w.d !== expectedWeekday) {
          getParsingFlags(config).weekdayMismatch = true;
        }
      }
      function dayOfYearFromWeekInfo(config) {
        var w2, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
        w2 = config._w;
        if (w2.GG != null || w2.W != null || w2.E != null) {
          dow = 1;
          doy = 4;
          weekYear = defaults3(
            w2.GG,
            config._a[YEAR],
            weekOfYear(createLocal(), 1, 4).year
          );
          week = defaults3(w2.W, 1);
          weekday = defaults3(w2.E, 1);
          if (weekday < 1 || weekday > 7) {
            weekdayOverflow = true;
          }
        } else {
          dow = config._locale._week.dow;
          doy = config._locale._week.doy;
          curWeek = weekOfYear(createLocal(), dow, doy);
          weekYear = defaults3(w2.gg, config._a[YEAR], curWeek.year);
          week = defaults3(w2.w, curWeek.week);
          if (w2.d != null) {
            weekday = w2.d;
            if (weekday < 0 || weekday > 6) {
              weekdayOverflow = true;
            }
          } else if (w2.e != null) {
            weekday = w2.e + dow;
            if (w2.e < 0 || w2.e > 6) {
              weekdayOverflow = true;
            }
          } else {
            weekday = dow;
          }
        }
        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
          getParsingFlags(config)._overflowWeeks = true;
        } else if (weekdayOverflow != null) {
          getParsingFlags(config)._overflowWeekday = true;
        } else {
          temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
          config._a[YEAR] = temp.year;
          config._dayOfYear = temp.dayOfYear;
        }
      }
      hooks.ISO_8601 = function() {
      };
      hooks.RFC_2822 = function() {
      };
      function configFromStringAndFormat(config) {
        if (config._f === hooks.ISO_8601) {
          configFromISO(config);
          return;
        }
        if (config._f === hooks.RFC_2822) {
          configFromRFC2822(config);
          return;
        }
        config._a = [];
        getParsingFlags(config).empty = true;
        var string = "" + config._i, i2, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen;
        tokens2 = expandFormat(config._f, config._locale).match(formattingTokens) || [];
        tokenLen = tokens2.length;
        for (i2 = 0; i2 < tokenLen; i2++) {
          token2 = tokens2[i2];
          parsedInput = (string.match(getParseRegexForToken(token2, config)) || [])[0];
          if (parsedInput) {
            skipped = string.substr(0, string.indexOf(parsedInput));
            if (skipped.length > 0) {
              getParsingFlags(config).unusedInput.push(skipped);
            }
            string = string.slice(
              string.indexOf(parsedInput) + parsedInput.length
            );
            totalParsedInputLength += parsedInput.length;
          }
          if (formatTokenFunctions[token2]) {
            if (parsedInput) {
              getParsingFlags(config).empty = false;
            } else {
              getParsingFlags(config).unusedTokens.push(token2);
            }
            addTimeToArrayFromToken(token2, parsedInput, config);
          } else if (config._strict && !parsedInput) {
            getParsingFlags(config).unusedTokens.push(token2);
          }
        }
        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
        if (string.length > 0) {
          getParsingFlags(config).unusedInput.push(string);
        }
        if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {
          getParsingFlags(config).bigHour = void 0;
        }
        getParsingFlags(config).parsedDateParts = config._a.slice(0);
        getParsingFlags(config).meridiem = config._meridiem;
        config._a[HOUR] = meridiemFixWrap(
          config._locale,
          config._a[HOUR],
          config._meridiem
        );
        era = getParsingFlags(config).era;
        if (era !== null) {
          config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
        }
        configFromArray(config);
        checkOverflow(config);
      }
      function meridiemFixWrap(locale2, hour, meridiem2) {
        var isPm;
        if (meridiem2 == null) {
          return hour;
        }
        if (locale2.meridiemHour != null) {
          return locale2.meridiemHour(hour, meridiem2);
        } else if (locale2.isPM != null) {
          isPm = locale2.isPM(meridiem2);
          if (isPm && hour < 12) {
            hour += 12;
          }
          if (!isPm && hour === 12) {
            hour = 0;
          }
          return hour;
        } else {
          return hour;
        }
      }
      function configFromStringAndArray(config) {
        var tempConfig, bestMoment, scoreToBeat, i2, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length;
        if (configfLen === 0) {
          getParsingFlags(config).invalidFormat = true;
          config._d = /* @__PURE__ */ new Date(NaN);
          return;
        }
        for (i2 = 0; i2 < configfLen; i2++) {
          currentScore = 0;
          validFormatFound = false;
          tempConfig = copyConfig({}, config);
          if (config._useUTC != null) {
            tempConfig._useUTC = config._useUTC;
          }
          tempConfig._f = config._f[i2];
          configFromStringAndFormat(tempConfig);
          if (isValid(tempConfig)) {
            validFormatFound = true;
          }
          currentScore += getParsingFlags(tempConfig).charsLeftOver;
          currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
          getParsingFlags(tempConfig).score = currentScore;
          if (!bestFormatIsValid) {
            if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) {
              scoreToBeat = currentScore;
              bestMoment = tempConfig;
              if (validFormatFound) {
                bestFormatIsValid = true;
              }
            }
          } else {
            if (currentScore < scoreToBeat) {
              scoreToBeat = currentScore;
              bestMoment = tempConfig;
            }
          }
        }
        extend(config, bestMoment || tempConfig);
      }
      function configFromObject(config) {
        if (config._d) {
          return;
        }
        var i2 = normalizeObjectUnits(config._i), dayOrDate = i2.day === void 0 ? i2.date : i2.day;
        config._a = map3(
          [i2.year, i2.month, dayOrDate, i2.hour, i2.minute, i2.second, i2.millisecond],
          function(obj) {
            return obj && parseInt(obj, 10);
          }
        );
        configFromArray(config);
      }
      function createFromConfig(config) {
        var res = new Moment6(checkOverflow(prepareConfig(config)));
        if (res._nextDay) {
          res.add(1, "d");
          res._nextDay = void 0;
        }
        return res;
      }
      function prepareConfig(config) {
        var input = config._i, format2 = config._f;
        config._locale = config._locale || getLocale(config._l);
        if (input === null || format2 === void 0 && input === "") {
          return createInvalid({ nullInput: true });
        }
        if (typeof input === "string") {
          config._i = input = config._locale.preparse(input);
        }
        if (isMoment(input)) {
          return new Moment6(checkOverflow(input));
        } else if (isDate(input)) {
          config._d = input;
        } else if (isArray2(format2)) {
          configFromStringAndArray(config);
        } else if (format2) {
          configFromStringAndFormat(config);
        } else {
          configFromInput(config);
        }
        if (!isValid(config)) {
          config._d = null;
        }
        return config;
      }
      function configFromInput(config) {
        var input = config._i;
        if (isUndefined(input)) {
          config._d = new Date(hooks.now());
        } else if (isDate(input)) {
          config._d = new Date(input.valueOf());
        } else if (typeof input === "string") {
          configFromString(config);
        } else if (isArray2(input)) {
          config._a = map3(input.slice(0), function(obj) {
            return parseInt(obj, 10);
          });
          configFromArray(config);
        } else if (isObject2(input)) {
          configFromObject(config);
        } else if (isNumber2(input)) {
          config._d = new Date(input);
        } else {
          hooks.createFromInputFallback(config);
        }
      }
      function createLocalOrUTC(input, format2, locale2, strict, isUTC) {
        var c2 = {};
        if (format2 === true || format2 === false) {
          strict = format2;
          format2 = void 0;
        }
        if (locale2 === true || locale2 === false) {
          strict = locale2;
          locale2 = void 0;
        }
        if (isObject2(input) && isObjectEmpty(input) || isArray2(input) && input.length === 0) {
          input = void 0;
        }
        c2._isAMomentObject = true;
        c2._useUTC = c2._isUTC = isUTC;
        c2._l = locale2;
        c2._i = input;
        c2._f = format2;
        c2._strict = strict;
        return createFromConfig(c2);
      }
      function createLocal(input, format2, locale2, strict) {
        return createLocalOrUTC(input, format2, locale2, strict, false);
      }
      var prototypeMin = deprecate(
        "moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",
        function() {
          var other = createLocal.apply(null, arguments);
          if (this.isValid() && other.isValid()) {
            return other < this ? this : other;
          } else {
            return createInvalid();
          }
        }
      ), prototypeMax = deprecate(
        "moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",
        function() {
          var other = createLocal.apply(null, arguments);
          if (this.isValid() && other.isValid()) {
            return other > this ? this : other;
          } else {
            return createInvalid();
          }
        }
      );
      function pickBy(fn2, moments) {
        var res, i2;
        if (moments.length === 1 && isArray2(moments[0])) {
          moments = moments[0];
        }
        if (!moments.length) {
          return createLocal();
        }
        res = moments[0];
        for (i2 = 1; i2 < moments.length; ++i2) {
          if (!moments[i2].isValid() || moments[i2][fn2](res)) {
            res = moments[i2];
          }
        }
        return res;
      }
      function min() {
        var args = [].slice.call(arguments, 0);
        return pickBy("isBefore", args);
      }
      function max() {
        var args = [].slice.call(arguments, 0);
        return pickBy("isAfter", args);
      }
      var now2 = function() {
        return Date.now ? Date.now() : +/* @__PURE__ */ new Date();
      };
      var ordering = [
        "year",
        "quarter",
        "month",
        "week",
        "day",
        "hour",
        "minute",
        "second",
        "millisecond"
      ];
      function isDurationValid(m2) {
        var key, unitHasDecimal = false, i2, orderLen = ordering.length;
        for (key in m2) {
          if (hasOwnProp(m2, key) && !(indexOf.call(ordering, key) !== -1 && (m2[key] == null || !isNaN(m2[key])))) {
            return false;
          }
        }
        for (i2 = 0; i2 < orderLen; ++i2) {
          if (m2[ordering[i2]]) {
            if (unitHasDecimal) {
              return false;
            }
            if (parseFloat(m2[ordering[i2]]) !== toInt(m2[ordering[i2]])) {
              unitHasDecimal = true;
            }
          }
        }
        return true;
      }
      function isValid$1() {
        return this._isValid;
      }
      function createInvalid$1() {
        return createDuration(NaN);
      }
      function Duration(duration) {
        var normalizedInput = normalizeObjectUnits(duration), years2 = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months2 = normalizedInput.month || 0, weeks2 = normalizedInput.week || normalizedInput.isoWeek || 0, days2 = normalizedInput.day || 0, hours2 = normalizedInput.hour || 0, minutes2 = normalizedInput.minute || 0, seconds2 = normalizedInput.second || 0, milliseconds2 = normalizedInput.millisecond || 0;
        this._isValid = isDurationValid(normalizedInput);
        this._milliseconds = +milliseconds2 + seconds2 * 1e3 + // 1000
        minutes2 * 6e4 + // 1000 * 60
        hours2 * 1e3 * 60 * 60;
        this._days = +days2 + weeks2 * 7;
        this._months = +months2 + quarters * 3 + years2 * 12;
        this._data = {};
        this._locale = getLocale();
        this._bubble();
      }
      function isDuration(obj) {
        return obj instanceof Duration;
      }
      function absRound(number) {
        if (number < 0) {
          return Math.round(-1 * number) * -1;
        } else {
          return Math.round(number);
        }
      }
      function compareArrays(array1, array2, dontConvert) {
        var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i2;
        for (i2 = 0; i2 < len; i2++) {
          if (dontConvert && array1[i2] !== array2[i2] || !dontConvert && toInt(array1[i2]) !== toInt(array2[i2])) {
            diffs++;
          }
        }
        return diffs + lengthDiff;
      }
      function offset(token2, separator) {
        addFormatToken(token2, 0, 0, function() {
          var offset2 = this.utcOffset(), sign3 = "+";
          if (offset2 < 0) {
            offset2 = -offset2;
            sign3 = "-";
          }
          return sign3 + zeroFill(~~(offset2 / 60), 2) + separator + zeroFill(~~offset2 % 60, 2);
        });
      }
      offset("Z", ":");
      offset("ZZ", "");
      addRegexToken("Z", matchShortOffset);
      addRegexToken("ZZ", matchShortOffset);
      addParseToken(["Z", "ZZ"], function(input, array, config) {
        config._useUTC = true;
        config._tzm = offsetFromString(matchShortOffset, input);
      });
      var chunkOffset = /([\+\-]|\d\d)/gi;
      function offsetFromString(matcher, string) {
        var matches = (string || "").match(matcher), chunk, parts, minutes2;
        if (matches === null) {
          return null;
        }
        chunk = matches[matches.length - 1] || [];
        parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
        minutes2 = +(parts[1] * 60) + toInt(parts[2]);
        return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2;
      }
      function cloneWithOffset(input, model) {
        var res, diff2;
        if (model._isUTC) {
          res = model.clone();
          diff2 = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
          res._d.setTime(res._d.valueOf() + diff2);
          hooks.updateOffset(res, false);
          return res;
        } else {
          return createLocal(input).local();
        }
      }
      function getDateOffset(m2) {
        return -Math.round(m2._d.getTimezoneOffset());
      }
      hooks.updateOffset = function() {
      };
      function getSetOffset(input, keepLocalTime, keepMinutes) {
        var offset2 = this._offset || 0, localAdjust;
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        if (input != null) {
          if (typeof input === "string") {
            input = offsetFromString(matchShortOffset, input);
            if (input === null) {
              return this;
            }
          } else if (Math.abs(input) < 16 && !keepMinutes) {
            input = input * 60;
          }
          if (!this._isUTC && keepLocalTime) {
            localAdjust = getDateOffset(this);
          }
          this._offset = input;
          this._isUTC = true;
          if (localAdjust != null) {
            this.add(localAdjust, "m");
          }
          if (offset2 !== input) {
            if (!keepLocalTime || this._changeInProgress) {
              addSubtract(
                this,
                createDuration(input - offset2, "m"),
                1,
                false
              );
            } else if (!this._changeInProgress) {
              this._changeInProgress = true;
              hooks.updateOffset(this, true);
              this._changeInProgress = null;
            }
          }
          return this;
        } else {
          return this._isUTC ? offset2 : getDateOffset(this);
        }
      }
      function getSetZone(input, keepLocalTime) {
        if (input != null) {
          if (typeof input !== "string") {
            input = -input;
          }
          this.utcOffset(input, keepLocalTime);
          return this;
        } else {
          return -this.utcOffset();
        }
      }
      function setOffsetToUTC(keepLocalTime) {
        return this.utcOffset(0, keepLocalTime);
      }
      function setOffsetToLocal(keepLocalTime) {
        if (this._isUTC) {
          this.utcOffset(0, keepLocalTime);
          this._isUTC = false;
          if (keepLocalTime) {
            this.subtract(getDateOffset(this), "m");
          }
        }
        return this;
      }
      function setOffsetToParsedOffset() {
        if (this._tzm != null) {
          this.utcOffset(this._tzm, false, true);
        } else if (typeof this._i === "string") {
          var tZone = offsetFromString(matchOffset, this._i);
          if (tZone != null) {
            this.utcOffset(tZone);
          } else {
            this.utcOffset(0, true);
          }
        }
        return this;
      }
      function hasAlignedHourOffset(input) {
        if (!this.isValid()) {
          return false;
        }
        input = input ? createLocal(input).utcOffset() : 0;
        return (this.utcOffset() - input) % 60 === 0;
      }
      function isDaylightSavingTime() {
        return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset();
      }
      function isDaylightSavingTimeShifted() {
        if (!isUndefined(this._isDSTShifted)) {
          return this._isDSTShifted;
        }
        var c2 = {}, other;
        copyConfig(c2, this);
        c2 = prepareConfig(c2);
        if (c2._a) {
          other = c2._isUTC ? createUTC(c2._a) : createLocal(c2._a);
          this._isDSTShifted = this.isValid() && compareArrays(c2._a, other.toArray()) > 0;
        } else {
          this._isDSTShifted = false;
        }
        return this._isDSTShifted;
      }
      function isLocal() {
        return this.isValid() ? !this._isUTC : false;
      }
      function isUtcOffset() {
        return this.isValid() ? this._isUTC : false;
      }
      function isUtc() {
        return this.isValid() ? this._isUTC && this._offset === 0 : false;
      }
      var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
      function createDuration(input, key) {
        var duration = input, match5 = null, sign3, ret, diffRes;
        if (isDuration(input)) {
          duration = {
            ms: input._milliseconds,
            d: input._days,
            M: input._months
          };
        } else if (isNumber2(input) || !isNaN(+input)) {
          duration = {};
          if (key) {
            duration[key] = +input;
          } else {
            duration.milliseconds = +input;
          }
        } else if (match5 = aspNetRegex.exec(input)) {
          sign3 = match5[1] === "-" ? -1 : 1;
          duration = {
            y: 0,
            d: toInt(match5[DATE]) * sign3,
            h: toInt(match5[HOUR]) * sign3,
            m: toInt(match5[MINUTE]) * sign3,
            s: toInt(match5[SECOND]) * sign3,
            ms: toInt(absRound(match5[MILLISECOND] * 1e3)) * sign3
            // the millisecond decimal point is included in the match
          };
        } else if (match5 = isoRegex.exec(input)) {
          sign3 = match5[1] === "-" ? -1 : 1;
          duration = {
            y: parseIso(match5[2], sign3),
            M: parseIso(match5[3], sign3),
            w: parseIso(match5[4], sign3),
            d: parseIso(match5[5], sign3),
            h: parseIso(match5[6], sign3),
            m: parseIso(match5[7], sign3),
            s: parseIso(match5[8], sign3)
          };
        } else if (duration == null) {
          duration = {};
        } else if (typeof duration === "object" && ("from" in duration || "to" in duration)) {
          diffRes = momentsDifference(
            createLocal(duration.from),
            createLocal(duration.to)
          );
          duration = {};
          duration.ms = diffRes.milliseconds;
          duration.M = diffRes.months;
        }
        ret = new Duration(duration);
        if (isDuration(input) && hasOwnProp(input, "_locale")) {
          ret._locale = input._locale;
        }
        if (isDuration(input) && hasOwnProp(input, "_isValid")) {
          ret._isValid = input._isValid;
        }
        return ret;
      }
      createDuration.fn = Duration.prototype;
      createDuration.invalid = createInvalid$1;
      function parseIso(inp, sign3) {
        var res = inp && parseFloat(inp.replace(",", "."));
        return (isNaN(res) ? 0 : res) * sign3;
      }
      function positiveMomentsDifference(base, other) {
        var res = {};
        res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
        if (base.clone().add(res.months, "M").isAfter(other)) {
          --res.months;
        }
        res.milliseconds = +other - +base.clone().add(res.months, "M");
        return res;
      }
      function momentsDifference(base, other) {
        var res;
        if (!(base.isValid() && other.isValid())) {
          return { milliseconds: 0, months: 0 };
        }
        other = cloneWithOffset(other, base);
        if (base.isBefore(other)) {
          res = positiveMomentsDifference(base, other);
        } else {
          res = positiveMomentsDifference(other, base);
          res.milliseconds = -res.milliseconds;
          res.months = -res.months;
        }
        return res;
      }
      function createAdder(direction, name) {
        return function(val, period) {
          var dur, tmp;
          if (period !== null && !isNaN(+period)) {
            deprecateSimple(
              name,
              "moment()." + name + "(period, number) is deprecated. Please use moment()." + name + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."
            );
            tmp = val;
            val = period;
            period = tmp;
          }
          dur = createDuration(val, period);
          addSubtract(this, dur, direction);
          return this;
        };
      }
      function addSubtract(mom, duration, isAdding, updateOffset) {
        var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months);
        if (!mom.isValid()) {
          return;
        }
        updateOffset = updateOffset == null ? true : updateOffset;
        if (months2) {
          setMonth(mom, get(mom, "Month") + months2 * isAdding);
        }
        if (days2) {
          set$1(mom, "Date", get(mom, "Date") + days2 * isAdding);
        }
        if (milliseconds2) {
          mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding);
        }
        if (updateOffset) {
          hooks.updateOffset(mom, days2 || months2);
        }
      }
      var add = createAdder(1, "add"), subtract = createAdder(-1, "subtract");
      function isString(input) {
        return typeof input === "string" || input instanceof String;
      }
      function isMomentInput(input) {
        return isMoment(input) || isDate(input) || isString(input) || isNumber2(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === void 0;
      }
      function isMomentInputObject(input) {
        var objectTest = isObject2(input) && !isObjectEmpty(input), propertyTest = false, properties = [
          "years",
          "year",
          "y",
          "months",
          "month",
          "M",
          "days",
          "day",
          "d",
          "dates",
          "date",
          "D",
          "hours",
          "hour",
          "h",
          "minutes",
          "minute",
          "m",
          "seconds",
          "second",
          "s",
          "milliseconds",
          "millisecond",
          "ms"
        ], i2, property, propertyLen = properties.length;
        for (i2 = 0; i2 < propertyLen; i2 += 1) {
          property = properties[i2];
          propertyTest = propertyTest || hasOwnProp(input, property);
        }
        return objectTest && propertyTest;
      }
      function isNumberOrStringArray(input) {
        var arrayTest = isArray2(input), dataTypeTest = false;
        if (arrayTest) {
          dataTypeTest = input.filter(function(item) {
            return !isNumber2(item) && isString(input);
          }).length === 0;
        }
        return arrayTest && dataTypeTest;
      }
      function isCalendarSpec(input) {
        var objectTest = isObject2(input) && !isObjectEmpty(input), propertyTest = false, properties = [
          "sameDay",
          "nextDay",
          "lastDay",
          "nextWeek",
          "lastWeek",
          "sameElse"
        ], i2, property;
        for (i2 = 0; i2 < properties.length; i2 += 1) {
          property = properties[i2];
          propertyTest = propertyTest || hasOwnProp(input, property);
        }
        return objectTest && propertyTest;
      }
      function getCalendarFormat(myMoment, now3) {
        var diff2 = myMoment.diff(now3, "days", true);
        return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse";
      }
      function calendar$1(time, formats) {
        if (arguments.length === 1) {
          if (!arguments[0]) {
            time = void 0;
            formats = void 0;
          } else if (isMomentInput(arguments[0])) {
            time = arguments[0];
            formats = void 0;
          } else if (isCalendarSpec(arguments[0])) {
            formats = arguments[0];
            time = void 0;
          }
        }
        var now3 = time || createLocal(), sod = cloneWithOffset(now3, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction2(formats[format2]) ? formats[format2].call(this, now3) : formats[format2]);
        return this.format(
          output || this.localeData().calendar(format2, this, createLocal(now3))
        );
      }
      function clone3() {
        return new Moment6(this);
      }
      function isAfter(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
          return false;
        }
        units = normalizeUnits(units) || "millisecond";
        if (units === "millisecond") {
          return this.valueOf() > localInput.valueOf();
        } else {
          return localInput.valueOf() < this.clone().startOf(units).valueOf();
        }
      }
      function isBefore(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
          return false;
        }
        units = normalizeUnits(units) || "millisecond";
        if (units === "millisecond") {
          return this.valueOf() < localInput.valueOf();
        } else {
          return this.clone().endOf(units).valueOf() < localInput.valueOf();
        }
      }
      function isBetween(from3, to3, units, inclusivity) {
        var localFrom = isMoment(from3) ? from3 : createLocal(from3), localTo = isMoment(to3) ? to3 : createLocal(to3);
        if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
          return false;
        }
        inclusivity = inclusivity || "()";
        return (inclusivity[0] === "(" ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ")" ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
      }
      function isSame(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input), inputMs;
        if (!(this.isValid() && localInput.isValid())) {
          return false;
        }
        units = normalizeUnits(units) || "millisecond";
        if (units === "millisecond") {
          return this.valueOf() === localInput.valueOf();
        } else {
          inputMs = localInput.valueOf();
          return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
        }
      }
      function isSameOrAfter(input, units) {
        return this.isSame(input, units) || this.isAfter(input, units);
      }
      function isSameOrBefore(input, units) {
        return this.isSame(input, units) || this.isBefore(input, units);
      }
      function diff(input, units, asFloat) {
        var that, zoneDelta, output;
        if (!this.isValid()) {
          return NaN;
        }
        that = cloneWithOffset(input, this);
        if (!that.isValid()) {
          return NaN;
        }
        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
        units = normalizeUnits(units);
        switch (units) {
          case "year":
            output = monthDiff(this, that) / 12;
            break;
          case "month":
            output = monthDiff(this, that);
            break;
          case "quarter":
            output = monthDiff(this, that) / 3;
            break;
          case "second":
            output = (this - that) / 1e3;
            break;
          // 1000
          case "minute":
            output = (this - that) / 6e4;
            break;
          // 1000 * 60
          case "hour":
            output = (this - that) / 36e5;
            break;
          // 1000 * 60 * 60
          case "day":
            output = (this - that - zoneDelta) / 864e5;
            break;
          // 1000 * 60 * 60 * 24, negate dst
          case "week":
            output = (this - that - zoneDelta) / 6048e5;
            break;
          // 1000 * 60 * 60 * 24 * 7, negate dst
          default:
            output = this - that;
        }
        return asFloat ? output : absFloor(output);
      }
      function monthDiff(a2, b2) {
        if (a2.date() < b2.date()) {
          return -monthDiff(b2, a2);
        }
        var wholeMonthDiff = (b2.year() - a2.year()) * 12 + (b2.month() - a2.month()), anchor = a2.clone().add(wholeMonthDiff, "months"), anchor2, adjust;
        if (b2 - anchor < 0) {
          anchor2 = a2.clone().add(wholeMonthDiff - 1, "months");
          adjust = (b2 - anchor) / (anchor - anchor2);
        } else {
          anchor2 = a2.clone().add(wholeMonthDiff + 1, "months");
          adjust = (b2 - anchor) / (anchor2 - anchor);
        }
        return -(wholeMonthDiff + adjust) || 0;
      }
      hooks.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ";
      hooks.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
      function toString() {
        return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
      }
      function toISOString(keepOffset) {
        if (!this.isValid()) {
          return null;
        }
        var utc = keepOffset !== true, m2 = utc ? this.clone().utc() : this;
        if (m2.year() < 0 || m2.year() > 9999) {
          return formatMoment(
            m2,
            utc ? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"
          );
        }
        if (isFunction2(Date.prototype.toISOString)) {
          if (utc) {
            return this.toDate().toISOString();
          } else {
            return new Date(this.valueOf() + this.utcOffset() * 60 * 1e3).toISOString().replace("Z", formatMoment(m2, "Z"));
          }
        }
        return formatMoment(
          m2,
          utc ? "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYY-MM-DD[T]HH:mm:ss.SSSZ"
        );
      }
      function inspect() {
        if (!this.isValid()) {
          return "moment.invalid(/* " + this._i + " */)";
        }
        var func = "moment", zone = "", prefix, year, datetime, suffix;
        if (!this.isLocal()) {
          func = this.utcOffset() === 0 ? "moment.utc" : "moment.parseZone";
          zone = "Z";
        }
        prefix = "[" + func + '("]';
        year = 0 <= this.year() && this.year() <= 9999 ? "YYYY" : "YYYYYY";
        datetime = "-MM-DD[T]HH:mm:ss.SSS";
        suffix = zone + '[")]';
        return this.format(prefix + year + datetime + suffix);
      }
      function format(inputString) {
        if (!inputString) {
          inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
        }
        var output = formatMoment(this, inputString);
        return this.localeData().postformat(output);
      }
      function from2(time, withoutSuffix) {
        if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
          return createDuration({ to: this, from: time }).locale(this.locale()).humanize(!withoutSuffix);
        } else {
          return this.localeData().invalidDate();
        }
      }
      function fromNow(withoutSuffix) {
        return this.from(createLocal(), withoutSuffix);
      }
      function to2(time, withoutSuffix) {
        if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
          return createDuration({ from: this, to: time }).locale(this.locale()).humanize(!withoutSuffix);
        } else {
          return this.localeData().invalidDate();
        }
      }
      function toNow(withoutSuffix) {
        return this.to(createLocal(), withoutSuffix);
      }
      function locale(key) {
        var newLocaleData;
        if (key === void 0) {
          return this._locale._abbr;
        } else {
          newLocaleData = getLocale(key);
          if (newLocaleData != null) {
            this._locale = newLocaleData;
          }
          return this;
        }
      }
      var lang = deprecate(
        "moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",
        function(key) {
          if (key === void 0) {
            return this.localeData();
          } else {
            return this.locale(key);
          }
        }
      );
      function localeData() {
        return this._locale;
      }
      var MS_PER_SECOND = 1e3, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
      function mod$1(dividend, divisor) {
        return (dividend % divisor + divisor) % divisor;
      }
      function localStartOfDate(y2, m2, d2) {
        if (y2 < 100 && y2 >= 0) {
          return new Date(y2 + 400, m2, d2) - MS_PER_400_YEARS;
        } else {
          return new Date(y2, m2, d2).valueOf();
        }
      }
      function utcStartOfDate(y2, m2, d2) {
        if (y2 < 100 && y2 >= 0) {
          return Date.UTC(y2 + 400, m2, d2) - MS_PER_400_YEARS;
        } else {
          return Date.UTC(y2, m2, d2);
        }
      }
      function startOf(units) {
        var time, startOfDate;
        units = normalizeUnits(units);
        if (units === void 0 || units === "millisecond" || !this.isValid()) {
          return this;
        }
        startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
        switch (units) {
          case "year":
            time = startOfDate(this.year(), 0, 1);
            break;
          case "quarter":
            time = startOfDate(
              this.year(),
              this.month() - this.month() % 3,
              1
            );
            break;
          case "month":
            time = startOfDate(this.year(), this.month(), 1);
            break;
          case "week":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - this.weekday()
            );
            break;
          case "isoWeek":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - (this.isoWeekday() - 1)
            );
            break;
          case "day":
          case "date":
            time = startOfDate(this.year(), this.month(), this.date());
            break;
          case "hour":
            time = this._d.valueOf();
            time -= mod$1(
              time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
              MS_PER_HOUR
            );
            break;
          case "minute":
            time = this._d.valueOf();
            time -= mod$1(time, MS_PER_MINUTE);
            break;
          case "second":
            time = this._d.valueOf();
            time -= mod$1(time, MS_PER_SECOND);
            break;
        }
        this._d.setTime(time);
        hooks.updateOffset(this, true);
        return this;
      }
      function endOf(units) {
        var time, startOfDate;
        units = normalizeUnits(units);
        if (units === void 0 || units === "millisecond" || !this.isValid()) {
          return this;
        }
        startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
        switch (units) {
          case "year":
            time = startOfDate(this.year() + 1, 0, 1) - 1;
            break;
          case "quarter":
            time = startOfDate(
              this.year(),
              this.month() - this.month() % 3 + 3,
              1
            ) - 1;
            break;
          case "month":
            time = startOfDate(this.year(), this.month() + 1, 1) - 1;
            break;
          case "week":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - this.weekday() + 7
            ) - 1;
            break;
          case "isoWeek":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - (this.isoWeekday() - 1) + 7
            ) - 1;
            break;
          case "day":
          case "date":
            time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
            break;
          case "hour":
            time = this._d.valueOf();
            time += MS_PER_HOUR - mod$1(
              time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
              MS_PER_HOUR
            ) - 1;
            break;
          case "minute":
            time = this._d.valueOf();
            time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
            break;
          case "second":
            time = this._d.valueOf();
            time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
            break;
        }
        this._d.setTime(time);
        hooks.updateOffset(this, true);
        return this;
      }
      function valueOf() {
        return this._d.valueOf() - (this._offset || 0) * 6e4;
      }
      function unix() {
        return Math.floor(this.valueOf() / 1e3);
      }
      function toDate() {
        return new Date(this.valueOf());
      }
      function toArray() {
        var m2 = this;
        return [
          m2.year(),
          m2.month(),
          m2.date(),
          m2.hour(),
          m2.minute(),
          m2.second(),
          m2.millisecond()
        ];
      }
      function toObject() {
        var m2 = this;
        return {
          years: m2.year(),
          months: m2.month(),
          date: m2.date(),
          hours: m2.hours(),
          minutes: m2.minutes(),
          seconds: m2.seconds(),
          milliseconds: m2.milliseconds()
        };
      }
      function toJSON() {
        return this.isValid() ? this.toISOString() : null;
      }
      function isValid$2() {
        return isValid(this);
      }
      function parsingFlags() {
        return extend({}, getParsingFlags(this));
      }
      function invalidAt() {
        return getParsingFlags(this).overflow;
      }
      function creationData() {
        return {
          input: this._i,
          format: this._f,
          locale: this._locale,
          isUTC: this._isUTC,
          strict: this._strict
        };
      }
      addFormatToken("N", 0, 0, "eraAbbr");
      addFormatToken("NN", 0, 0, "eraAbbr");
      addFormatToken("NNN", 0, 0, "eraAbbr");
      addFormatToken("NNNN", 0, 0, "eraName");
      addFormatToken("NNNNN", 0, 0, "eraNarrow");
      addFormatToken("y", ["y", 1], "yo", "eraYear");
      addFormatToken("y", ["yy", 2], 0, "eraYear");
      addFormatToken("y", ["yyy", 3], 0, "eraYear");
      addFormatToken("y", ["yyyy", 4], 0, "eraYear");
      addRegexToken("N", matchEraAbbr);
      addRegexToken("NN", matchEraAbbr);
      addRegexToken("NNN", matchEraAbbr);
      addRegexToken("NNNN", matchEraName);
      addRegexToken("NNNNN", matchEraNarrow);
      addParseToken(
        ["N", "NN", "NNN", "NNNN", "NNNNN"],
        function(input, array, config, token2) {
          var era = config._locale.erasParse(input, token2, config._strict);
          if (era) {
            getParsingFlags(config).era = era;
          } else {
            getParsingFlags(config).invalidEra = input;
          }
        }
      );
      addRegexToken("y", matchUnsigned);
      addRegexToken("yy", matchUnsigned);
      addRegexToken("yyy", matchUnsigned);
      addRegexToken("yyyy", matchUnsigned);
      addRegexToken("yo", matchEraYearOrdinal);
      addParseToken(["y", "yy", "yyy", "yyyy"], YEAR);
      addParseToken(["yo"], function(input, array, config, token2) {
        var match5;
        if (config._locale._eraYearOrdinalRegex) {
          match5 = input.match(config._locale._eraYearOrdinalRegex);
        }
        if (config._locale.eraYearOrdinalParse) {
          array[YEAR] = config._locale.eraYearOrdinalParse(input, match5);
        } else {
          array[YEAR] = parseInt(input, 10);
        }
      });
      function localeEras(m2, format2) {
        var i2, l2, date, eras = this._eras || getLocale("en")._eras;
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          switch (typeof eras[i2].since) {
            case "string":
              date = hooks(eras[i2].since).startOf("day");
              eras[i2].since = date.valueOf();
              break;
          }
          switch (typeof eras[i2].until) {
            case "undefined":
              eras[i2].until = Infinity;
              break;
            case "string":
              date = hooks(eras[i2].until).startOf("day").valueOf();
              eras[i2].until = date.valueOf();
              break;
          }
        }
        return eras;
      }
      function localeErasParse(eraName, format2, strict) {
        var i2, l2, eras = this.eras(), name, abbr, narrow;
        eraName = eraName.toUpperCase();
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          name = eras[i2].name.toUpperCase();
          abbr = eras[i2].abbr.toUpperCase();
          narrow = eras[i2].narrow.toUpperCase();
          if (strict) {
            switch (format2) {
              case "N":
              case "NN":
              case "NNN":
                if (abbr === eraName) {
                  return eras[i2];
                }
                break;
              case "NNNN":
                if (name === eraName) {
                  return eras[i2];
                }
                break;
              case "NNNNN":
                if (narrow === eraName) {
                  return eras[i2];
                }
                break;
            }
          } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
            return eras[i2];
          }
        }
      }
      function localeErasConvertYear(era, year) {
        var dir = era.since <= era.until ? 1 : -1;
        if (year === void 0) {
          return hooks(era.since).year();
        } else {
          return hooks(era.since).year() + (year - era.offset) * dir;
        }
      }
      function getEraName() {
        var i2, l2, val, eras = this.localeData().eras();
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          val = this.clone().startOf("day").valueOf();
          if (eras[i2].since <= val && val <= eras[i2].until) {
            return eras[i2].name;
          }
          if (eras[i2].until <= val && val <= eras[i2].since) {
            return eras[i2].name;
          }
        }
        return "";
      }
      function getEraNarrow() {
        var i2, l2, val, eras = this.localeData().eras();
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          val = this.clone().startOf("day").valueOf();
          if (eras[i2].since <= val && val <= eras[i2].until) {
            return eras[i2].narrow;
          }
          if (eras[i2].until <= val && val <= eras[i2].since) {
            return eras[i2].narrow;
          }
        }
        return "";
      }
      function getEraAbbr() {
        var i2, l2, val, eras = this.localeData().eras();
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          val = this.clone().startOf("day").valueOf();
          if (eras[i2].since <= val && val <= eras[i2].until) {
            return eras[i2].abbr;
          }
          if (eras[i2].until <= val && val <= eras[i2].since) {
            return eras[i2].abbr;
          }
        }
        return "";
      }
      function getEraYear() {
        var i2, l2, dir, val, eras = this.localeData().eras();
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          dir = eras[i2].since <= eras[i2].until ? 1 : -1;
          val = this.clone().startOf("day").valueOf();
          if (eras[i2].since <= val && val <= eras[i2].until || eras[i2].until <= val && val <= eras[i2].since) {
            return (this.year() - hooks(eras[i2].since).year()) * dir + eras[i2].offset;
          }
        }
        return this.year();
      }
      function erasNameRegex(isStrict) {
        if (!hasOwnProp(this, "_erasNameRegex")) {
          computeErasParse.call(this);
        }
        return isStrict ? this._erasNameRegex : this._erasRegex;
      }
      function erasAbbrRegex(isStrict) {
        if (!hasOwnProp(this, "_erasAbbrRegex")) {
          computeErasParse.call(this);
        }
        return isStrict ? this._erasAbbrRegex : this._erasRegex;
      }
      function erasNarrowRegex(isStrict) {
        if (!hasOwnProp(this, "_erasNarrowRegex")) {
          computeErasParse.call(this);
        }
        return isStrict ? this._erasNarrowRegex : this._erasRegex;
      }
      function matchEraAbbr(isStrict, locale2) {
        return locale2.erasAbbrRegex(isStrict);
      }
      function matchEraName(isStrict, locale2) {
        return locale2.erasNameRegex(isStrict);
      }
      function matchEraNarrow(isStrict, locale2) {
        return locale2.erasNarrowRegex(isStrict);
      }
      function matchEraYearOrdinal(isStrict, locale2) {
        return locale2._eraYearOrdinalRegex || matchUnsigned;
      }
      function computeErasParse() {
        var abbrPieces = [], namePieces = [], narrowPieces = [], mixedPieces = [], i2, l2, erasName, erasAbbr, erasNarrow, eras = this.eras();
        for (i2 = 0, l2 = eras.length; i2 < l2; ++i2) {
          erasName = regexEscape(eras[i2].name);
          erasAbbr = regexEscape(eras[i2].abbr);
          erasNarrow = regexEscape(eras[i2].narrow);
          namePieces.push(erasName);
          abbrPieces.push(erasAbbr);
          narrowPieces.push(erasNarrow);
          mixedPieces.push(erasName);
          mixedPieces.push(erasAbbr);
          mixedPieces.push(erasNarrow);
        }
        this._erasRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
        this._erasNameRegex = new RegExp("^(" + namePieces.join("|") + ")", "i");
        this._erasAbbrRegex = new RegExp("^(" + abbrPieces.join("|") + ")", "i");
        this._erasNarrowRegex = new RegExp(
          "^(" + narrowPieces.join("|") + ")",
          "i"
        );
      }
      addFormatToken(0, ["gg", 2], 0, function() {
        return this.weekYear() % 100;
      });
      addFormatToken(0, ["GG", 2], 0, function() {
        return this.isoWeekYear() % 100;
      });
      function addWeekYearFormatToken(token2, getter) {
        addFormatToken(0, [token2, token2.length], 0, getter);
      }
      addWeekYearFormatToken("gggg", "weekYear");
      addWeekYearFormatToken("ggggg", "weekYear");
      addWeekYearFormatToken("GGGG", "isoWeekYear");
      addWeekYearFormatToken("GGGGG", "isoWeekYear");
      addRegexToken("G", matchSigned);
      addRegexToken("g", matchSigned);
      addRegexToken("GG", match1to2, match2);
      addRegexToken("gg", match1to2, match2);
      addRegexToken("GGGG", match1to4, match4);
      addRegexToken("gggg", match1to4, match4);
      addRegexToken("GGGGG", match1to6, match6);
      addRegexToken("ggggg", match1to6, match6);
      addWeekParseToken(
        ["gggg", "ggggg", "GGGG", "GGGGG"],
        function(input, week, config, token2) {
          week[token2.substr(0, 2)] = toInt(input);
        }
      );
      addWeekParseToken(["gg", "GG"], function(input, week, config, token2) {
        week[token2] = hooks.parseTwoDigitYear(input);
      });
      function getSetWeekYear(input) {
        return getSetWeekYearHelper.call(
          this,
          input,
          this.week(),
          this.weekday() + this.localeData()._week.dow,
          this.localeData()._week.dow,
          this.localeData()._week.doy
        );
      }
      function getSetISOWeekYear(input) {
        return getSetWeekYearHelper.call(
          this,
          input,
          this.isoWeek(),
          this.isoWeekday(),
          1,
          4
        );
      }
      function getISOWeeksInYear() {
        return weeksInYear(this.year(), 1, 4);
      }
      function getISOWeeksInISOWeekYear() {
        return weeksInYear(this.isoWeekYear(), 1, 4);
      }
      function getWeeksInYear() {
        var weekInfo = this.localeData()._week;
        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
      }
      function getWeeksInWeekYear() {
        var weekInfo = this.localeData()._week;
        return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
      }
      function getSetWeekYearHelper(input, week, weekday, dow, doy) {
        var weeksTarget;
        if (input == null) {
          return weekOfYear(this, dow, doy).year;
        } else {
          weeksTarget = weeksInYear(input, dow, doy);
          if (week > weeksTarget) {
            week = weeksTarget;
          }
          return setWeekAll.call(this, input, week, weekday, dow, doy);
        }
      }
      function setWeekAll(weekYear, week, weekday, dow, doy) {
        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
        this.year(date.getUTCFullYear());
        this.month(date.getUTCMonth());
        this.date(date.getUTCDate());
        return this;
      }
      addFormatToken("Q", 0, "Qo", "quarter");
      addRegexToken("Q", match1);
      addParseToken("Q", function(input, array) {
        array[MONTH] = (toInt(input) - 1) * 3;
      });
      function getSetQuarter(input) {
        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
      }
      addFormatToken("D", ["DD", 2], "Do", "date");
      addRegexToken("D", match1to2, match1to2NoLeadingZero);
      addRegexToken("DD", match1to2, match2);
      addRegexToken("Do", function(isStrict, locale2) {
        return isStrict ? locale2._dayOfMonthOrdinalParse || locale2._ordinalParse : locale2._dayOfMonthOrdinalParseLenient;
      });
      addParseToken(["D", "DD"], DATE);
      addParseToken("Do", function(input, array) {
        array[DATE] = toInt(input.match(match1to2)[0]);
      });
      var getSetDayOfMonth = makeGetSet("Date", true);
      addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
      addRegexToken("DDD", match1to3);
      addRegexToken("DDDD", match3);
      addParseToken(["DDD", "DDDD"], function(input, array, config) {
        config._dayOfYear = toInt(input);
      });
      function getSetDayOfYear(input) {
        var dayOfYear = Math.round(
          (this.clone().startOf("day") - this.clone().startOf("year")) / 864e5
        ) + 1;
        return input == null ? dayOfYear : this.add(input - dayOfYear, "d");
      }
      addFormatToken("m", ["mm", 2], 0, "minute");
      addRegexToken("m", match1to2, match1to2HasZero);
      addRegexToken("mm", match1to2, match2);
      addParseToken(["m", "mm"], MINUTE);
      var getSetMinute = makeGetSet("Minutes", false);
      addFormatToken("s", ["ss", 2], 0, "second");
      addRegexToken("s", match1to2, match1to2HasZero);
      addRegexToken("ss", match1to2, match2);
      addParseToken(["s", "ss"], SECOND);
      var getSetSecond = makeGetSet("Seconds", false);
      addFormatToken("S", 0, 0, function() {
        return ~~(this.millisecond() / 100);
      });
      addFormatToken(0, ["SS", 2], 0, function() {
        return ~~(this.millisecond() / 10);
      });
      addFormatToken(0, ["SSS", 3], 0, "millisecond");
      addFormatToken(0, ["SSSS", 4], 0, function() {
        return this.millisecond() * 10;
      });
      addFormatToken(0, ["SSSSS", 5], 0, function() {
        return this.millisecond() * 100;
      });
      addFormatToken(0, ["SSSSSS", 6], 0, function() {
        return this.millisecond() * 1e3;
      });
      addFormatToken(0, ["SSSSSSS", 7], 0, function() {
        return this.millisecond() * 1e4;
      });
      addFormatToken(0, ["SSSSSSSS", 8], 0, function() {
        return this.millisecond() * 1e5;
      });
      addFormatToken(0, ["SSSSSSSSS", 9], 0, function() {
        return this.millisecond() * 1e6;
      });
      addRegexToken("S", match1to3, match1);
      addRegexToken("SS", match1to3, match2);
      addRegexToken("SSS", match1to3, match3);
      var token, getSetMillisecond;
      for (token = "SSSS"; token.length <= 9; token += "S") {
        addRegexToken(token, matchUnsigned);
      }
      function parseMs(input, array) {
        array[MILLISECOND] = toInt(("0." + input) * 1e3);
      }
      for (token = "S"; token.length <= 9; token += "S") {
        addParseToken(token, parseMs);
      }
      getSetMillisecond = makeGetSet("Milliseconds", false);
      addFormatToken("z", 0, 0, "zoneAbbr");
      addFormatToken("zz", 0, 0, "zoneName");
      function getZoneAbbr() {
        return this._isUTC ? "UTC" : "";
      }
      function getZoneName() {
        return this._isUTC ? "Coordinated Universal Time" : "";
      }
      var proto = Moment6.prototype;
      proto.add = add;
      proto.calendar = calendar$1;
      proto.clone = clone3;
      proto.diff = diff;
      proto.endOf = endOf;
      proto.format = format;
      proto.from = from2;
      proto.fromNow = fromNow;
      proto.to = to2;
      proto.toNow = toNow;
      proto.get = stringGet;
      proto.invalidAt = invalidAt;
      proto.isAfter = isAfter;
      proto.isBefore = isBefore;
      proto.isBetween = isBetween;
      proto.isSame = isSame;
      proto.isSameOrAfter = isSameOrAfter;
      proto.isSameOrBefore = isSameOrBefore;
      proto.isValid = isValid$2;
      proto.lang = lang;
      proto.locale = locale;
      proto.localeData = localeData;
      proto.max = prototypeMax;
      proto.min = prototypeMin;
      proto.parsingFlags = parsingFlags;
      proto.set = stringSet;
      proto.startOf = startOf;
      proto.subtract = subtract;
      proto.toArray = toArray;
      proto.toObject = toObject;
      proto.toDate = toDate;
      proto.toISOString = toISOString;
      proto.inspect = inspect;
      if (typeof Symbol !== "undefined" && Symbol.for != null) {
        proto[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = function() {
          return "Moment<" + this.format() + ">";
        };
      }
      proto.toJSON = toJSON;
      proto.toString = toString;
      proto.unix = unix;
      proto.valueOf = valueOf;
      proto.creationData = creationData;
      proto.eraName = getEraName;
      proto.eraNarrow = getEraNarrow;
      proto.eraAbbr = getEraAbbr;
      proto.eraYear = getEraYear;
      proto.year = getSetYear;
      proto.isLeapYear = getIsLeapYear;
      proto.weekYear = getSetWeekYear;
      proto.isoWeekYear = getSetISOWeekYear;
      proto.quarter = proto.quarters = getSetQuarter;
      proto.month = getSetMonth;
      proto.daysInMonth = getDaysInMonth;
      proto.week = proto.weeks = getSetWeek;
      proto.isoWeek = proto.isoWeeks = getSetISOWeek;
      proto.weeksInYear = getWeeksInYear;
      proto.weeksInWeekYear = getWeeksInWeekYear;
      proto.isoWeeksInYear = getISOWeeksInYear;
      proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
      proto.date = getSetDayOfMonth;
      proto.day = proto.days = getSetDayOfWeek;
      proto.weekday = getSetLocaleDayOfWeek;
      proto.isoWeekday = getSetISODayOfWeek;
      proto.dayOfYear = getSetDayOfYear;
      proto.hour = proto.hours = getSetHour;
      proto.minute = proto.minutes = getSetMinute;
      proto.second = proto.seconds = getSetSecond;
      proto.millisecond = proto.milliseconds = getSetMillisecond;
      proto.utcOffset = getSetOffset;
      proto.utc = setOffsetToUTC;
      proto.local = setOffsetToLocal;
      proto.parseZone = setOffsetToParsedOffset;
      proto.hasAlignedHourOffset = hasAlignedHourOffset;
      proto.isDST = isDaylightSavingTime;
      proto.isLocal = isLocal;
      proto.isUtcOffset = isUtcOffset;
      proto.isUtc = isUtc;
      proto.isUTC = isUtc;
      proto.zoneAbbr = getZoneAbbr;
      proto.zoneName = getZoneName;
      proto.dates = deprecate(
        "dates accessor is deprecated. Use date instead.",
        getSetDayOfMonth
      );
      proto.months = deprecate(
        "months accessor is deprecated. Use month instead",
        getSetMonth
      );
      proto.years = deprecate(
        "years accessor is deprecated. Use year instead",
        getSetYear
      );
      proto.zone = deprecate(
        "moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",
        getSetZone
      );
      proto.isDSTShifted = deprecate(
        "isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",
        isDaylightSavingTimeShifted
      );
      function createUnix(input) {
        return createLocal(input * 1e3);
      }
      function createInZone() {
        return createLocal.apply(null, arguments).parseZone();
      }
      function preParsePostFormat(string) {
        return string;
      }
      var proto$1 = Locale.prototype;
      proto$1.calendar = calendar;
      proto$1.longDateFormat = longDateFormat;
      proto$1.invalidDate = invalidDate;
      proto$1.ordinal = ordinal;
      proto$1.preparse = preParsePostFormat;
      proto$1.postformat = preParsePostFormat;
      proto$1.relativeTime = relativeTime;
      proto$1.pastFuture = pastFuture;
      proto$1.set = set2;
      proto$1.eras = localeEras;
      proto$1.erasParse = localeErasParse;
      proto$1.erasConvertYear = localeErasConvertYear;
      proto$1.erasAbbrRegex = erasAbbrRegex;
      proto$1.erasNameRegex = erasNameRegex;
      proto$1.erasNarrowRegex = erasNarrowRegex;
      proto$1.months = localeMonths;
      proto$1.monthsShort = localeMonthsShort;
      proto$1.monthsParse = localeMonthsParse;
      proto$1.monthsRegex = monthsRegex;
      proto$1.monthsShortRegex = monthsShortRegex;
      proto$1.week = localeWeek;
      proto$1.firstDayOfYear = localeFirstDayOfYear;
      proto$1.firstDayOfWeek = localeFirstDayOfWeek;
      proto$1.weekdays = localeWeekdays;
      proto$1.weekdaysMin = localeWeekdaysMin;
      proto$1.weekdaysShort = localeWeekdaysShort;
      proto$1.weekdaysParse = localeWeekdaysParse;
      proto$1.weekdaysRegex = weekdaysRegex;
      proto$1.weekdaysShortRegex = weekdaysShortRegex;
      proto$1.weekdaysMinRegex = weekdaysMinRegex;
      proto$1.isPM = localeIsPM;
      proto$1.meridiem = localeMeridiem;
      function get$1(format2, index, field, setter) {
        var locale2 = getLocale(), utc = createUTC().set(setter, index);
        return locale2[field](utc, format2);
      }
      function listMonthsImpl(format2, index, field) {
        if (isNumber2(format2)) {
          index = format2;
          format2 = void 0;
        }
        format2 = format2 || "";
        if (index != null) {
          return get$1(format2, index, field, "month");
        }
        var i2, out = [];
        for (i2 = 0; i2 < 12; i2++) {
          out[i2] = get$1(format2, i2, field, "month");
        }
        return out;
      }
      function listWeekdaysImpl(localeSorted, format2, index, field) {
        if (typeof localeSorted === "boolean") {
          if (isNumber2(format2)) {
            index = format2;
            format2 = void 0;
          }
          format2 = format2 || "";
        } else {
          format2 = localeSorted;
          index = format2;
          localeSorted = false;
          if (isNumber2(format2)) {
            index = format2;
            format2 = void 0;
          }
          format2 = format2 || "";
        }
        var locale2 = getLocale(), shift = localeSorted ? locale2._week.dow : 0, i2, out = [];
        if (index != null) {
          return get$1(format2, (index + shift) % 7, field, "day");
        }
        for (i2 = 0; i2 < 7; i2++) {
          out[i2] = get$1(format2, (i2 + shift) % 7, field, "day");
        }
        return out;
      }
      function listMonths(format2, index) {
        return listMonthsImpl(format2, index, "months");
      }
      function listMonthsShort(format2, index) {
        return listMonthsImpl(format2, index, "monthsShort");
      }
      function listWeekdays(localeSorted, format2, index) {
        return listWeekdaysImpl(localeSorted, format2, index, "weekdays");
      }
      function listWeekdaysShort(localeSorted, format2, index) {
        return listWeekdaysImpl(localeSorted, format2, index, "weekdaysShort");
      }
      function listWeekdaysMin(localeSorted, format2, index) {
        return listWeekdaysImpl(localeSorted, format2, index, "weekdaysMin");
      }
      getSetGlobalLocale("en", {
        eras: [
          {
            since: "0001-01-01",
            until: Infinity,
            offset: 1,
            name: "Anno Domini",
            narrow: "AD",
            abbr: "AD"
          },
          {
            since: "0000-12-31",
            until: -Infinity,
            offset: 1,
            name: "Before Christ",
            narrow: "BC",
            abbr: "BC"
          }
        ],
        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
        ordinal: function(number) {
          var b2 = number % 10, output = toInt(number % 100 / 10) === 1 ? "th" : b2 === 1 ? "st" : b2 === 2 ? "nd" : b2 === 3 ? "rd" : "th";
          return number + output;
        }
      });
      hooks.lang = deprecate(
        "moment.lang is deprecated. Use moment.locale instead.",
        getSetGlobalLocale
      );
      hooks.langData = deprecate(
        "moment.langData is deprecated. Use moment.localeData instead.",
        getLocale
      );
      var mathAbs = Math.abs;
      function abs() {
        var data = this._data;
        this._milliseconds = mathAbs(this._milliseconds);
        this._days = mathAbs(this._days);
        this._months = mathAbs(this._months);
        data.milliseconds = mathAbs(data.milliseconds);
        data.seconds = mathAbs(data.seconds);
        data.minutes = mathAbs(data.minutes);
        data.hours = mathAbs(data.hours);
        data.months = mathAbs(data.months);
        data.years = mathAbs(data.years);
        return this;
      }
      function addSubtract$1(duration, input, value, direction) {
        var other = createDuration(input, value);
        duration._milliseconds += direction * other._milliseconds;
        duration._days += direction * other._days;
        duration._months += direction * other._months;
        return duration._bubble();
      }
      function add$1(input, value) {
        return addSubtract$1(this, input, value, 1);
      }
      function subtract$1(input, value) {
        return addSubtract$1(this, input, value, -1);
      }
      function absCeil(number) {
        if (number < 0) {
          return Math.floor(number);
        } else {
          return Math.ceil(number);
        }
      }
      function bubble() {
        var milliseconds2 = this._milliseconds, days2 = this._days, months2 = this._months, data = this._data, seconds2, minutes2, hours2, years2, monthsFromDays;
        if (!(milliseconds2 >= 0 && days2 >= 0 && months2 >= 0 || milliseconds2 <= 0 && days2 <= 0 && months2 <= 0)) {
          milliseconds2 += absCeil(monthsToDays(months2) + days2) * 864e5;
          days2 = 0;
          months2 = 0;
        }
        data.milliseconds = milliseconds2 % 1e3;
        seconds2 = absFloor(milliseconds2 / 1e3);
        data.seconds = seconds2 % 60;
        minutes2 = absFloor(seconds2 / 60);
        data.minutes = minutes2 % 60;
        hours2 = absFloor(minutes2 / 60);
        data.hours = hours2 % 24;
        days2 += absFloor(hours2 / 24);
        monthsFromDays = absFloor(daysToMonths(days2));
        months2 += monthsFromDays;
        days2 -= absCeil(monthsToDays(monthsFromDays));
        years2 = absFloor(months2 / 12);
        months2 %= 12;
        data.days = days2;
        data.months = months2;
        data.years = years2;
        return this;
      }
      function daysToMonths(days2) {
        return days2 * 4800 / 146097;
      }
      function monthsToDays(months2) {
        return months2 * 146097 / 4800;
      }
      function as(units) {
        if (!this.isValid()) {
          return NaN;
        }
        var days2, months2, milliseconds2 = this._milliseconds;
        units = normalizeUnits(units);
        if (units === "month" || units === "quarter" || units === "year") {
          days2 = this._days + milliseconds2 / 864e5;
          months2 = this._months + daysToMonths(days2);
          switch (units) {
            case "month":
              return months2;
            case "quarter":
              return months2 / 3;
            case "year":
              return months2 / 12;
          }
        } else {
          days2 = this._days + Math.round(monthsToDays(this._months));
          switch (units) {
            case "week":
              return days2 / 7 + milliseconds2 / 6048e5;
            case "day":
              return days2 + milliseconds2 / 864e5;
            case "hour":
              return days2 * 24 + milliseconds2 / 36e5;
            case "minute":
              return days2 * 1440 + milliseconds2 / 6e4;
            case "second":
              return days2 * 86400 + milliseconds2 / 1e3;
            // Math.floor prevents floating point math errors here
            case "millisecond":
              return Math.floor(days2 * 864e5) + milliseconds2;
            default:
              throw new Error("Unknown unit " + units);
          }
        }
      }
      function makeAs(alias) {
        return function() {
          return this.as(alias);
        };
      }
      var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf$1 = asMilliseconds;
      function clone$1() {
        return createDuration(this);
      }
      function get$2(units) {
        units = normalizeUnits(units);
        return this.isValid() ? this[units + "s"]() : NaN;
      }
      function makeGetter(name) {
        return function() {
          return this.isValid() ? this._data[name] : NaN;
        };
      }
      var milliseconds = makeGetter("milliseconds"), seconds = makeGetter("seconds"), minutes = makeGetter("minutes"), hours = makeGetter("hours"), days = makeGetter("days"), months = makeGetter("months"), years = makeGetter("years");
      function weeks() {
        return absFloor(this.days() / 7);
      }
      var round2 = Math.round, thresholds = {
        ss: 44,
        // a few seconds to seconds
        s: 45,
        // seconds to minute
        m: 45,
        // minutes to hour
        h: 22,
        // hours to day
        d: 26,
        // days to month/week
        w: null,
        // weeks to month
        M: 11
        // months to year
      };
      function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale2) {
        return locale2.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
      }
      function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) {
        var duration = createDuration(posNegDuration).abs(), seconds2 = round2(duration.as("s")), minutes2 = round2(duration.as("m")), hours2 = round2(duration.as("h")), days2 = round2(duration.as("d")), months2 = round2(duration.as("M")), weeks2 = round2(duration.as("w")), years2 = round2(duration.as("y")), a2 = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2];
        if (thresholds2.w != null) {
          a2 = a2 || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2];
        }
        a2 = a2 || months2 <= 1 && ["M"] || months2 < thresholds2.M && ["MM", months2] || years2 <= 1 && ["y"] || ["yy", years2];
        a2[2] = withoutSuffix;
        a2[3] = +posNegDuration > 0;
        a2[4] = locale2;
        return substituteTimeAgo.apply(null, a2);
      }
      function getSetRelativeTimeRounding(roundingFunction) {
        if (roundingFunction === void 0) {
          return round2;
        }
        if (typeof roundingFunction === "function") {
          round2 = roundingFunction;
          return true;
        }
        return false;
      }
      function getSetRelativeTimeThreshold(threshold, limit) {
        if (thresholds[threshold] === void 0) {
          return false;
        }
        if (limit === void 0) {
          return thresholds[threshold];
        }
        thresholds[threshold] = limit;
        if (threshold === "s") {
          thresholds.ss = limit - 1;
        }
        return true;
      }
      function humanize(argWithSuffix, argThresholds) {
        if (!this.isValid()) {
          return this.localeData().invalidDate();
        }
        var withSuffix = false, th2 = thresholds, locale2, output;
        if (typeof argWithSuffix === "object") {
          argThresholds = argWithSuffix;
          argWithSuffix = false;
        }
        if (typeof argWithSuffix === "boolean") {
          withSuffix = argWithSuffix;
        }
        if (typeof argThresholds === "object") {
          th2 = Object.assign({}, thresholds, argThresholds);
          if (argThresholds.s != null && argThresholds.ss == null) {
            th2.ss = argThresholds.s - 1;
          }
        }
        locale2 = this.localeData();
        output = relativeTime$1(this, !withSuffix, th2, locale2);
        if (withSuffix) {
          output = locale2.pastFuture(+this, output);
        }
        return locale2.postformat(output);
      }
      var abs$1 = Math.abs;
      function sign2(x2) {
        return (x2 > 0) - (x2 < 0) || +x2;
      }
      function toISOString$1() {
        if (!this.isValid()) {
          return this.localeData().invalidDate();
        }
        var seconds2 = abs$1(this._milliseconds) / 1e3, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s2, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
        if (!total) {
          return "P0D";
        }
        minutes2 = absFloor(seconds2 / 60);
        hours2 = absFloor(minutes2 / 60);
        seconds2 %= 60;
        minutes2 %= 60;
        years2 = absFloor(months2 / 12);
        months2 %= 12;
        s2 = seconds2 ? seconds2.toFixed(3).replace(/\.?0+$/, "") : "";
        totalSign = total < 0 ? "-" : "";
        ymSign = sign2(this._months) !== sign2(total) ? "-" : "";
        daysSign = sign2(this._days) !== sign2(total) ? "-" : "";
        hmsSign = sign2(this._milliseconds) !== sign2(total) ? "-" : "";
        return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s2 + "S" : "");
      }
      var proto$2 = Duration.prototype;
      proto$2.isValid = isValid$1;
      proto$2.abs = abs;
      proto$2.add = add$1;
      proto$2.subtract = subtract$1;
      proto$2.as = as;
      proto$2.asMilliseconds = asMilliseconds;
      proto$2.asSeconds = asSeconds;
      proto$2.asMinutes = asMinutes;
      proto$2.asHours = asHours;
      proto$2.asDays = asDays;
      proto$2.asWeeks = asWeeks;
      proto$2.asMonths = asMonths;
      proto$2.asQuarters = asQuarters;
      proto$2.asYears = asYears;
      proto$2.valueOf = valueOf$1;
      proto$2._bubble = bubble;
      proto$2.clone = clone$1;
      proto$2.get = get$2;
      proto$2.milliseconds = milliseconds;
      proto$2.seconds = seconds;
      proto$2.minutes = minutes;
      proto$2.hours = hours;
      proto$2.days = days;
      proto$2.weeks = weeks;
      proto$2.months = months;
      proto$2.years = years;
      proto$2.humanize = humanize;
      proto$2.toISOString = toISOString$1;
      proto$2.toString = toISOString$1;
      proto$2.toJSON = toISOString$1;
      proto$2.locale = locale;
      proto$2.localeData = localeData;
      proto$2.toIsoString = deprecate(
        "toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",
        toISOString$1
      );
      proto$2.lang = lang;
      addFormatToken("X", 0, 0, "unix");
      addFormatToken("x", 0, 0, "valueOf");
      addRegexToken("x", matchSigned);
      addRegexToken("X", matchTimestamp);
      addParseToken("X", function(input, array, config) {
        config._d = new Date(parseFloat(input) * 1e3);
      });
      addParseToken("x", function(input, array, config) {
        config._d = new Date(toInt(input));
      });
      hooks.version = "2.30.1";
      setHookCallback(createLocal);
      hooks.fn = proto;
      hooks.min = min;
      hooks.max = max;
      hooks.now = now2;
      hooks.utc = createUTC;
      hooks.unix = createUnix;
      hooks.months = listMonths;
      hooks.isDate = isDate;
      hooks.locale = getSetGlobalLocale;
      hooks.invalid = createInvalid;
      hooks.duration = createDuration;
      hooks.isMoment = isMoment;
      hooks.weekdays = listWeekdays;
      hooks.parseZone = createInZone;
      hooks.localeData = getLocale;
      hooks.isDuration = isDuration;
      hooks.monthsShort = listMonthsShort;
      hooks.weekdaysMin = listWeekdaysMin;
      hooks.defineLocale = defineLocale;
      hooks.updateLocale = updateLocale;
      hooks.locales = listLocales;
      hooks.weekdaysShort = listWeekdaysShort;
      hooks.normalizeUnits = normalizeUnits;
      hooks.relativeTimeRounding = getSetRelativeTimeRounding;
      hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
      hooks.calendarFormat = getCalendarFormat;
      hooks.prototype = proto;
      hooks.HTML5_FMT = {
        DATETIME_LOCAL: "YYYY-MM-DDTHH:mm",
        // <input type="datetime-local" />
        DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss",
        // <input type="datetime-local" step="1" />
        DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS",
        // <input type="datetime-local" step="0.001" />
        DATE: "YYYY-MM-DD",
        // <input type="date" />
        TIME: "HH:mm",
        // <input type="time" />
        TIME_SECONDS: "HH:mm:ss",
        // <input type="time" step="1" />
        TIME_MS: "HH:mm:ss.SSS",
        // <input type="time" step="0.001" />
        WEEK: "GGGG-[W]WW",
        // <input type="week" />
        MONTH: "YYYY-MM"
        // <input type="month" />
      };
      return hooks;
    }));
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/utils.js
var require_utils = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.simpleFormatter = exports.htmlFormatter = exports.escapeRegexString = void 0;
    function escapeRegexString(str) {
      return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
    }
    exports.escapeRegexString = escapeRegexString;
    var htmlFormatter = class {
      asking(answer, hint) {
        return `<span style='color:#2196f3'>${!hint ? "[...]" : `[${hint}]`}</span>`;
      }
      showingAnswer(answer, hint) {
        return `<span style='color:#2196f3'>${answer}</span>`;
      }
      hiding(answer, hint) {
        return `${!hint ? "..." : `[${hint}]`} `;
      }
    };
    exports.htmlFormatter = htmlFormatter;
    var simpleFormatter = class {
      asking(answer, hint) {
        return `${!hint ? "[...]" : `[${hint}]`}`;
      }
      showingAnswer(answer, hint) {
        return answer;
      }
      hiding(answer, hint) {
        return `...`;
      }
    };
    exports.simpleFormatter = simpleFormatter;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeFieldEnum.js
var require_ClozeFieldEnum = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeFieldEnum.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeFieldEnum = void 0;
    var ClozeFieldEnum;
    (function(ClozeFieldEnum2) {
      ClozeFieldEnum2["seq"] = "seq";
      ClozeFieldEnum2["answer"] = "answer";
      ClozeFieldEnum2["hint"] = "hint";
    })(ClozeFieldEnum || (exports.ClozeFieldEnum = ClozeFieldEnum = {}));
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeRegExp.js
var require_ClozeRegExp = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeRegExp.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeRegExp = void 0;
    var ClozeFieldEnum_1 = require_ClozeFieldEnum();
    var ClozeRegExp = class {
      constructor(pattern, clozeFieldsOrder, flags) {
        this.regex = new RegExp(pattern, flags);
        this.clozeFieldsOrder = clozeFieldsOrder;
      }
      exec(str) {
        let match2 = this.regex.exec(str);
        if (!match2) {
          return null;
        }
        if (this.clozeFieldsOrder.indexOf(ClozeFieldEnum_1.ClozeFieldEnum.answer) == -1) {
          throw new Error("Cloze text not found in clozeFieldsOrder");
        }
        if (this.clozeFieldsOrder.indexOf(ClozeFieldEnum_1.ClozeFieldEnum.hint) == -1) {
          throw new Error("Cloze hint not found in clozeFieldsOrder");
        }
        if (this.clozeFieldsOrder.indexOf(ClozeFieldEnum_1.ClozeFieldEnum.seq) == -1) {
          match2.seq = null;
        } else {
          match2.seq = match2[this.clozeFieldsOrder.indexOf(ClozeFieldEnum_1.ClozeFieldEnum.seq) + 1];
        }
        match2.raw = match2[0];
        match2.answer = match2[this.clozeFieldsOrder.indexOf(ClozeFieldEnum_1.ClozeFieldEnum.answer) + 1];
        match2.hint = match2[this.clozeFieldsOrder.indexOf(ClozeFieldEnum_1.ClozeFieldEnum.hint) + 1];
        return match2;
      }
      test(str) {
        return this.regex.test(str);
      }
    };
    exports.ClozeRegExp = ClozeRegExp;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNote.js
var require_ClozeNote = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNote.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeNote = void 0;
    var ClozeNote = class {
      /**
       * Creates a new ClozeNote instance.
       *
       * @param raw The raw text of the cloze note before processing.
       */
      constructor(raw, patterns) {
        this._raw = raw;
        const { clozeDeletions, numCards } = this.initParsing(raw, patterns);
        this._clozeDeletions = clozeDeletions;
        this._numCards = numCards;
      }
      get raw() {
        return this._raw;
      }
      get numCards() {
        return this._numCards;
      }
    };
    exports.ClozeNote = ClozeNote;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNoteClassic.js
var require_ClozeNoteClassic = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNoteClassic.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeNoteClassic = void 0;
    var ClozeNote_1 = require_ClozeNote();
    var utils_1 = require_utils();
    var ClozeTypeEnum_1 = require_ClozeTypeEnum();
    var ClozeNoteClassic = class extends ClozeNote_1.ClozeNote {
      constructor(raw, patterns) {
        super(raw, patterns);
      }
      get clozeType() {
        return ClozeTypeEnum_1.ClozeTypeEnum.CLASSIC;
      }
      initParsing(rawNote, patterns) {
        let clozeDeletions = [];
        let numCards = 0;
        patterns.forEach((pattern) => {
          const regex = pattern.getClozeRegex(ClozeTypeEnum_1.ClozeTypeEnum.CLASSIC);
          let match2;
          while (match2 = regex.exec(rawNote)) {
            if (!match2.seq) {
              break;
            }
            let newCloze = {
              raw: match2.raw,
              answer: match2.answer,
              seq: parseInt(match2.seq),
              hint: match2.hint
            };
            clozeDeletions.push(newCloze);
            if (numCards < newCloze.seq) {
              numCards = newCloze.seq;
            }
          }
        });
        return { clozeDeletions, numCards };
      }
      getCardFront(cardIndex, formatter) {
        if (cardIndex >= this._numCards || cardIndex < 0) {
          throw new Error(`Card ${cardIndex} does not exist`);
        }
        if (!formatter) {
          formatter = new utils_1.simpleFormatter();
        }
        let frontText = this.raw;
        for (const deletion of this._clozeDeletions) {
          if (deletion.seq !== cardIndex + 1) {
            frontText = frontText.replace(deletion.raw, deletion.answer);
            continue;
          }
          frontText = frontText.replace(deletion.raw, formatter.asking(deletion.answer, deletion.hint));
        }
        return frontText;
      }
      getCardBack(cardIndex, formatter) {
        if (cardIndex >= this._numCards || cardIndex < 0) {
          throw new Error(`Card ${cardIndex} does not exist`);
        }
        if (!formatter) {
          formatter = new utils_1.simpleFormatter();
        }
        let backText = this.raw;
        for (const deletion of this._clozeDeletions) {
          if (deletion.seq === cardIndex + 1) {
            backText = backText.replace(deletion.raw, formatter.showingAnswer(deletion.answer, deletion.hint));
          } else {
            backText = backText.replace(deletion.raw, deletion.answer);
          }
        }
        return backText;
      }
    };
    exports.ClozeNoteClassic = ClozeNoteClassic;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNoteOL.js
var require_ClozeNoteOL = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNoteOL.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeNoteOL = void 0;
    var ClozeNote_1 = require_ClozeNote();
    var utils_1 = require_utils();
    var ClozeTypeEnum_1 = require_ClozeTypeEnum();
    var ClozeNoteOL = class extends ClozeNote_1.ClozeNote {
      constructor(raw, patterns) {
        super(raw, patterns);
      }
      get clozeType() {
        return ClozeTypeEnum_1.ClozeTypeEnum.OVERLAPPING;
      }
      initParsing(rawNote, patterns) {
        let clozeDeletions = [];
        let numCards = 0;
        patterns.forEach((pattern) => {
          const regex = pattern.getClozeRegex(ClozeTypeEnum_1.ClozeTypeEnum.OVERLAPPING);
          let match2;
          while (match2 = regex.exec(rawNote)) {
            if (!match2.seq) {
              break;
            }
            let newCloze = {
              raw: match2.raw,
              answer: match2.answer,
              seq: match2.seq,
              hint: match2.hint
            };
            clozeDeletions.push(newCloze);
            if (numCards < newCloze.seq.length) {
              numCards = newCloze.seq.length;
            }
          }
        });
        return { clozeDeletions, numCards };
      }
      getCardFront(cardIndex, formatter) {
        if (cardIndex >= this._numCards || cardIndex < 0) {
          throw new Error(`Card ${cardIndex} does not exist`);
        }
        if (!formatter) {
          formatter = new utils_1.simpleFormatter();
        }
        let frontText = this.raw;
        for (const deletion of this._clozeDeletions) {
          let clozeAction = "s";
          if (cardIndex < deletion.seq.length) {
            clozeAction = deletion.seq[cardIndex];
          }
          switch (clozeAction) {
            case "a":
              frontText = frontText.replace(deletion.raw, formatter.asking(deletion.answer, deletion.hint));
              break;
            case "h":
              frontText = frontText.replace(deletion.raw, formatter.hiding(deletion.answer, deletion.hint));
              break;
            case "s":
              frontText = frontText.replace(deletion.raw, deletion.answer);
              break;
          }
        }
        return frontText;
      }
      getCardBack(cardIndex, formatter) {
        if (cardIndex >= this._numCards || cardIndex < 0) {
          throw new Error(`Card ${cardIndex} does not exist`);
        }
        if (!formatter) {
          formatter = new utils_1.simpleFormatter();
        }
        let backText = this.raw;
        for (const deletion of this._clozeDeletions) {
          let clozeAction = "s";
          if (cardIndex < deletion.seq.length) {
            clozeAction = deletion.seq[cardIndex];
          }
          switch (clozeAction) {
            case "a":
              backText = backText.replace(deletion.raw, formatter.showingAnswer(deletion.answer, deletion.hint));
              break;
            case "h":
              backText = backText.replace(deletion.raw, formatter.hiding(deletion.answer, deletion.hint));
              break;
            case "s":
              backText = backText.replace(deletion.raw, deletion.answer);
              break;
          }
        }
        return backText;
      }
    };
    exports.ClozeNoteOL = ClozeNoteOL;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNoteSimple.js
var require_ClozeNoteSimple = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeNoteSimple.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeNoteSimple = void 0;
    var ClozeNote_1 = require_ClozeNote();
    var ClozeTypeEnum_1 = require_ClozeTypeEnum();
    var utils_1 = require_utils();
    var ClozeNoteSimple = class extends ClozeNote_1.ClozeNote {
      constructor(raw, patterns) {
        super(raw, patterns);
      }
      get clozeType() {
        return ClozeTypeEnum_1.ClozeTypeEnum.SIMPLE;
      }
      initParsing(rawNote, patterns) {
        let clozeDeletions = [];
        let numCards = 0;
        patterns.forEach((pattern) => {
          const regex = pattern.getClozeRegex(ClozeTypeEnum_1.ClozeTypeEnum.SIMPLE);
          let match2;
          while (match2 = regex.exec(rawNote)) {
            numCards++;
            let newCloze = {
              raw: match2.raw,
              answer: match2.answer,
              seq: numCards,
              hint: match2.hint
            };
            clozeDeletions.push(newCloze);
          }
        });
        return { clozeDeletions, numCards };
      }
      getCardFront(cardIndex, formatter) {
        if (cardIndex >= this._numCards || cardIndex < 0) {
          throw new Error(`Card ${cardIndex} does not exist`);
        }
        if (!formatter) {
          formatter = new utils_1.simpleFormatter();
        }
        let frontText = this.raw;
        for (const deletion of this._clozeDeletions) {
          if (deletion.seq !== cardIndex + 1) {
            frontText = frontText.replace(deletion.raw, deletion.answer);
            continue;
          }
          frontText = frontText.replace(deletion.raw, formatter.asking(deletion.answer, deletion.hint));
        }
        return frontText;
      }
      getCardBack(cardIndex, formatter) {
        if (cardIndex >= this._numCards || cardIndex < 0) {
          throw new Error(`Card ${cardIndex} does not exist`);
        }
        if (!formatter) {
          formatter = new utils_1.simpleFormatter();
        }
        let backText = this.raw;
        for (const deletion of this._clozeDeletions) {
          if (deletion.seq === cardIndex + 1) {
            backText = backText.replace(deletion.raw, formatter.showingAnswer(deletion.answer, deletion.hint));
          } else {
            backText = backText.replace(deletion.raw, deletion.answer);
          }
        }
        return backText;
      }
    };
    exports.ClozeNoteSimple = ClozeNoteSimple;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeTypeEnum.js
var require_ClozeTypeEnum = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeTypeEnum.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.NoteClassByClozeType = exports.ClozeTypesPriority = exports.ClozeTypeEnum = void 0;
    var ClozeNoteClassic_1 = require_ClozeNoteClassic();
    var ClozeNoteOL_1 = require_ClozeNoteOL();
    var ClozeNoteSimple_1 = require_ClozeNoteSimple();
    var ClozeTypeEnum;
    (function(ClozeTypeEnum2) {
      ClozeTypeEnum2["CLASSIC"] = "classic";
      ClozeTypeEnum2["OVERLAPPING"] = "overlapping";
      ClozeTypeEnum2["SIMPLE"] = "simple";
    })(ClozeTypeEnum || (exports.ClozeTypeEnum = ClozeTypeEnum = {}));
    exports.ClozeTypesPriority = [
      ClozeTypeEnum.CLASSIC,
      ClozeTypeEnum.OVERLAPPING,
      ClozeTypeEnum.SIMPLE
      // Cloze Simple must be the last one because it is a subset of Cloze Classic and Cloze Overlapping
    ];
    exports.NoteClassByClozeType = {
      [ClozeTypeEnum.CLASSIC]: ClozeNoteClassic_1.ClozeNoteClassic,
      [ClozeTypeEnum.OVERLAPPING]: ClozeNoteOL_1.ClozeNoteOL,
      [ClozeTypeEnum.SIMPLE]: ClozeNoteSimple_1.ClozeNoteSimple
    };
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozePattern.js
var require_ClozePattern = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozePattern.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozePattern = void 0;
    var utils_1 = require_utils();
    var ClozeRegExp_1 = require_ClozeRegExp();
    var ClozeFieldEnum_1 = require_ClozeFieldEnum();
    var ClozeTypeEnum_1 = require_ClozeTypeEnum();
    var numPatternRegex = new RegExp(`\\[(?:(?:\\\\\\])?[^\\]]?)+?\\d+(?:(?:\\\\\\])?[^\\]]?)+?\\]`);
    var hintPatternRegex = new RegExp(`\\[(?:(?:\\\\\\])?[^\\]]?)+?hint(?:(?:\\\\\\])?[^\\]]?)+?\\]`);
    var answerKeyword = `answer`;
    var ClozePattern = class _ClozePattern {
      constructor(raw) {
        this.clozeRegexByType = {
          [ClozeTypeEnum_1.ClozeTypeEnum.CLASSIC]: void 0,
          [ClozeTypeEnum_1.ClozeTypeEnum.OVERLAPPING]: void 0,
          [ClozeTypeEnum_1.ClozeTypeEnum.SIMPLE]: void 0
        };
        this.generateClozeRegexByType = {
          [ClozeTypeEnum_1.ClozeTypeEnum.CLASSIC]: this.generateClozeClassicRegex,
          [ClozeTypeEnum_1.ClozeTypeEnum.OVERLAPPING]: this.generateClozeOLRegex,
          [ClozeTypeEnum_1.ClozeTypeEnum.SIMPLE]: this.generateClozeSimpleRegex
        };
        this._raw = raw;
        let _numMatch = numPatternRegex.exec(raw);
        let _hintMatch = hintPatternRegex.exec(raw);
        if (!_numMatch) {
          throw new Error("No cloze number pattern found");
        }
        if (!_hintMatch) {
          throw new Error("No cloze hint pattern found");
        }
        if (raw.indexOf(answerKeyword) == -1) {
          throw new Error(`No answer keyword (${answerKeyword}) found in the pattern.`);
        }
        this.numPattern = _numMatch;
        this.hintPattern = _hintMatch;
        this.numRegex = _ClozePattern.processPattern(_numMatch[0], (text) => text.replace(/\d+/g, "(\\d+)"));
        this.seqRegex = _ClozePattern.processPattern(_numMatch[0], (text) => text.replace(/\d+/g, "([ash]+)"));
        this.hintRegex = _ClozePattern.processPattern(_hintMatch[0], (text) => text.replace(/hint/g, "(.+?)"));
        this.hintRegex = "(?:" + this.hintRegex + ")?";
        this._clozeFieldOrder = [ClozeFieldEnum_1.ClozeFieldEnum.answer, ClozeFieldEnum_1.ClozeFieldEnum.hint, ClozeFieldEnum_1.ClozeFieldEnum.seq];
        let positions2 = {
          [ClozeFieldEnum_1.ClozeFieldEnum.answer]: raw.indexOf(answerKeyword),
          [ClozeFieldEnum_1.ClozeFieldEnum.hint]: this.hintPattern.index,
          [ClozeFieldEnum_1.ClozeFieldEnum.seq]: this.numPattern.index
        };
        this._clozeFieldOrder.sort((a2, b2) => positions2[a2] - positions2[b2]);
      }
      static processPattern(text, rplc) {
        let ans = text.substring(1, text.length - 1);
        ans = ans.replace(/\\\[/g, "[").replace(/\\]/g, "]");
        ans = (0, utils_1.escapeRegexString)(ans);
        ans = rplc(ans);
        return ans;
      }
      generateClozeRegexStr(first, firstReplace, second, secondReplace) {
        let begin = this._raw.slice(0, first.index);
        let middle = this._raw.slice(first.index + first[0].length, second.index);
        let ending = this._raw.slice(second.index + second[0].length, this._raw.length);
        let regexStr = (0, utils_1.escapeRegexString)(begin) + firstReplace + (0, utils_1.escapeRegexString)(middle) + secondReplace + (0, utils_1.escapeRegexString)(ending);
        regexStr = regexStr.replace(answerKeyword, "(.+?)");
        return regexStr;
      }
      generateClozeSimpleRegex(pattern) {
        let regexStr;
        if (pattern.numPattern.index < pattern.hintPattern.index) {
          regexStr = pattern.generateClozeRegexStr(pattern.numPattern, "", pattern.hintPattern, pattern.hintRegex);
        } else {
          regexStr = pattern.generateClozeRegexStr(pattern.hintPattern, pattern.hintRegex, pattern.numPattern, "");
        }
        let clozeFieldsOrderWithoutSeq = pattern._clozeFieldOrder.filter((x2) => x2 != ClozeFieldEnum_1.ClozeFieldEnum.seq);
        return new ClozeRegExp_1.ClozeRegExp(regexStr, clozeFieldsOrderWithoutSeq, "g");
      }
      generateClozeClassicRegex(pattern) {
        let regexStr;
        if (pattern.numPattern.index < pattern.hintPattern.index) {
          regexStr = pattern.generateClozeRegexStr(pattern.numPattern, pattern.numRegex, pattern.hintPattern, pattern.hintRegex);
        } else {
          regexStr = pattern.generateClozeRegexStr(pattern.hintPattern, pattern.hintRegex, pattern.numPattern, pattern.numRegex);
        }
        return new ClozeRegExp_1.ClozeRegExp(regexStr, pattern._clozeFieldOrder, "g");
      }
      generateClozeOLRegex(pattern) {
        let regexStr;
        if (pattern.numPattern.index < pattern.hintPattern.index) {
          regexStr = pattern.generateClozeRegexStr(pattern.numPattern, pattern.seqRegex, pattern.hintPattern, pattern.hintRegex);
        } else {
          regexStr = pattern.generateClozeRegexStr(pattern.hintPattern, pattern.hintRegex, pattern.numPattern, pattern.seqRegex);
        }
        return new ClozeRegExp_1.ClozeRegExp(regexStr, pattern._clozeFieldOrder, "g");
      }
      get clozeFieldsOrder() {
        return this._clozeFieldOrder;
      }
      getClozeRegex(clozeType) {
        let clozeRegex = this.clozeRegexByType[clozeType];
        if (clozeRegex != void 0) {
          clozeRegex.regex.lastIndex = 0;
          return clozeRegex;
        }
        clozeRegex = this.generateClozeRegexByType[clozeType](this);
        this.clozeRegexByType[clozeType] = clozeRegex;
        return clozeRegex;
      }
      hasClozeType(text, clozeType) {
        for (const priorityType of ClozeTypeEnum_1.ClozeTypesPriority) {
          if (this.getClozeRegex(priorityType).test(text)) {
            return clozeType == priorityType;
          }
        }
        return false;
      }
      getClozeTypes(text) {
        const clozeTypes = [];
        for (const priorityType of ClozeTypeEnum_1.ClozeTypesPriority) {
          if (this.getClozeRegex(priorityType).test(text)) {
            clozeTypes.push(priorityType);
          }
        }
        return clozeTypes;
      }
      getMainClozeType(text) {
        for (const priorityType of ClozeTypeEnum_1.ClozeTypesPriority) {
          if (this.getClozeRegex(priorityType).test(text)) {
            return priorityType;
          }
        }
        return null;
      }
    };
    exports.ClozePattern = ClozePattern;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeCrafter.js
var require_ClozeCrafter = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/implementation/ClozeCrafter.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeCrafter = void 0;
    var ClozePattern_1 = require_ClozePattern();
    var ClozeTypeEnum_1 = require_ClozeTypeEnum();
    var ClozeCrafter3 = class {
      constructor(patterns) {
        this.patterns = patterns.map((patternStr) => new ClozePattern_1.ClozePattern(patternStr));
      }
      createClozeNote(text) {
        const noteType = this.getNoteType(text);
        if (noteType === null) {
          return null;
        }
        const selectedClass = ClozeTypeEnum_1.NoteClassByClozeType[noteType];
        const clozeNote = new selectedClass(text, this.patterns);
        return clozeNote;
      }
      getNoteType(text) {
        let noteType = null;
        for (const pattern of this.patterns) {
          const currentType = pattern.getMainClozeType(text);
          if (currentType !== null && (noteType === null || ClozeTypeEnum_1.ClozeTypesPriority.indexOf(currentType) < ClozeTypeEnum_1.ClozeTypesPriority.indexOf(noteType))) {
            noteType = currentType;
          }
        }
        return noteType;
      }
      isClozeNote(text) {
        return this.getNoteType(text) !== null;
      }
    };
    exports.ClozeCrafter = ClozeCrafter3;
  }
});

// node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/index.js
var require_dist = __commonJS({
  "node_modules/.pnpm/clozecraft@0.4.0/node_modules/clozecraft/dist/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ClozeTypesPriority = exports.ClozeTypeEnum = exports.ClozeCrafter = void 0;
    var ClozeCrafter_1 = require_ClozeCrafter();
    Object.defineProperty(exports, "ClozeCrafter", { enumerable: true, get: function() {
      return ClozeCrafter_1.ClozeCrafter;
    } });
    var ClozeTypeEnum_1 = require_ClozeTypeEnum();
    Object.defineProperty(exports, "ClozeTypeEnum", { enumerable: true, get: function() {
      return ClozeTypeEnum_1.ClozeTypeEnum;
    } });
    Object.defineProperty(exports, "ClozeTypesPriority", { enumerable: true, get: function() {
      return ClozeTypeEnum_1.ClozeTypesPriority;
    } });
  }
});

// node_modules/.pnpm/pagerank.js@1.0.2/node_modules/pagerank.js/lib/index.js
var require_lib = __commonJS({
  "node_modules/.pnpm/pagerank.js@1.0.2/node_modules/pagerank.js/lib/index.js"(exports, module2) {
    "use strict";
    function forOwn(object, callback2) {
      if (typeof object === "object" && typeof callback2 === "function") {
        for (var key in object) {
          if (object.hasOwnProperty(key) === true) {
            if (callback2(key, object[key]) === false) {
              break;
            }
          }
        }
      }
    }
    module2.exports = (function() {
      var self = {
        count: 0,
        edges: {},
        nodes: {}
      };
      self.link = function(source, target, weight) {
        if (isFinite(weight) !== true || weight === null) {
          weight = 1;
        }
        weight = parseFloat(weight);
        if (self.nodes.hasOwnProperty(source) !== true) {
          self.count++;
          self.nodes[source] = {
            weight: 0,
            outbound: 0
          };
        }
        self.nodes[source].outbound += weight;
        if (self.nodes.hasOwnProperty(target) !== true) {
          self.count++;
          self.nodes[target] = {
            weight: 0,
            outbound: 0
          };
        }
        if (self.edges.hasOwnProperty(source) !== true) {
          self.edges[source] = {};
        }
        if (self.edges[source].hasOwnProperty(target) !== true) {
          self.edges[source][target] = 0;
        }
        self.edges[source][target] += weight;
      };
      self.rank = function(alpha2, epsilon, callback2) {
        var delta = 1, inverse = 1 / self.count;
        forOwn(self.edges, function(source) {
          if (self.nodes[source].outbound > 0) {
            forOwn(self.edges[source], function(target) {
              self.edges[source][target] /= self.nodes[source].outbound;
            });
          }
        });
        forOwn(self.nodes, function(key) {
          self.nodes[key].weight = inverse;
        });
        while (delta > epsilon) {
          var leak = 0, nodes = {};
          forOwn(self.nodes, function(key, value) {
            nodes[key] = value.weight;
            if (value.outbound === 0) {
              leak += value.weight;
            }
            self.nodes[key].weight = 0;
          });
          leak *= alpha2;
          forOwn(self.nodes, function(source) {
            forOwn(self.edges[source], function(target, weight) {
              self.nodes[target].weight += alpha2 * nodes[source] * weight;
            });
            self.nodes[source].weight += (1 - alpha2) * inverse + leak * inverse;
          });
          delta = 0;
          forOwn(self.nodes, function(key, value) {
            delta += Math.abs(value.weight - nodes[key]);
          });
        }
        forOwn(self.nodes, function(key) {
          return callback2(key, self.nodes[key].weight);
        });
      };
      self.reset = function() {
        self.count = 0;
        self.edges = {};
        self.nodes = {};
      };
      return self;
    })();
  }
});

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => SRPlugin
});
module.exports = __toCommonJS(main_exports);
var import_obsidian39 = require("obsidian");

// src/command-manager.ts
var import_obsidian33 = require("obsidian");

// src/lang/locale/en.ts
var en = {
  language: "en",
  languageName: "English",
  // flashcard-modal.tsx
  CRAM_MODE: "Cram Mode",
  REVIEW_MODE: "Review Mode",
  DECKS: "Decks",
  DUE_CARDS: "Due Cards",
  DUE: "Due",
  NEW_CARDS: "New Cards",
  SEEN_CARDS: "Seen Cards",
  SEEN: "Seen",
  TOTAL_CARDS: "Total Cards",
  TOTAL: "Total",
  BACK: "Back",
  SKIP: "Skip",
  EDIT_CARD: "Edit Card",
  RESET_CARD_PROGRESS: "Reset card's progress",
  HARD: "Hard",
  GOOD: "Good",
  EASY: "Easy",
  SHOW_ANSWER: "Show Answer",
  CARD_PROGRESS_RESET: "Card's progress has been reset.",
  SAVE: "Save",
  CANCEL: "Cancel",
  NO_INPUT: "No input provided.",
  CURRENT_EASE_HELP_TEXT: "Current Ease: ",
  CURRENT_INTERVAL_HELP_TEXT: "Current Interval: ",
  CARD_GENERATED_FROM: "Generated from: ${notePath}",
  JUMP_TO: "Jump to card",
  JUMP_TO_AND_CLOSE: "Close and jump to card",
  OPEN_IN_BACKGROUND: "Open card in background",
  VIEW_CARD_INFO: "View Card Info",
  DELETE_CARD: "Delete Card",
  DELETE_CARD_CONFIRMATION: "This action cannot be undone and might alter your notes in unwanted ways. Are you sure you want to delete this card?",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Review a note",
  REVIEW_CARDS: "Review flashcards",
  REVIEW_DIFFICULTY_FILE_MENU: "Review: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Review note as ${difficulty}",
  REVIEW_CARD_DIFFICULTY_CMD: "Review card as ${difficulty}",
  CRAM_ALL_CARDS: "Select a deck to cram",
  REVIEW_ALL_CARDS: "Review flashcards from all notes",
  REVIEW_CARDS_IN_NOTE: "Review flashcards in this note",
  CRAM_CARDS_IN_NOTE: "Cram flashcards in this note",
  VIEW_STATS: "View statistics",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "Review: ${dueNotesCount} note(s), ${dueFlashcardsCount} card(s) due",
  SYNC_TIME_TAKEN: "Sync took ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "Note is saved under ignored folder (check settings).",
  PLEASE_TAG_NOTE: "Please tag the note appropriately for reviewing (in settings).",
  RESPONSE_RECEIVED: "Response received.",
  NO_DECK_EXISTS: "No deck exists for ${deckName}",
  ALL_CAUGHT_UP: "You're all caught up now :D.",
  REVIEW_REMINDER_NOTICE: "Flashcards are ready to review. Return to Obsidian to continue learning.",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} day(s)",
  MONTHS_STR_IVL: "${interval} month(s)",
  YEARS_STR_IVL: "${interval} year(s)",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}y",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  PLUGIN_DATA_STORE_INFO: "Schedule data is stored in markdown files inside your vault (in the configured folder under Schedule Data). Note schedules are identified by a unique ID (sr-id) added to each note's frontmatter, so they survive renames and moves inside or outside Obsidian. Card schedules are keyed by a hash of the card text - editing a card's front side will reset its schedule.",
  MIGRATE_TO_PLUGIN_DATA: "Migrate scheduling data to plugin data?",
  CONFIRM_MIGRATE_TO_PLUGIN_DATA: "All <!--SR:...--> comments and sr-* frontmatter fields will be moved to markdown schedule files in the vault, and an sr-id field will be added to each note's frontmatter as a stable identifier. This may take a moment on large vaults. Do not edit notes until migration is complete.",
  MIGRATING_TO_PLUGIN_DATA: "Migrating scheduling data to plugin data...",
  MIGRATE_TO_NOTES: "Migrate scheduling data back to notes?",
  CONFIRM_MIGRATE_TO_NOTES: "All scheduling data will be written back as <!--SR:...--> comments and sr-* frontmatter fields. This may take a moment on large vaults. Do not edit notes until migration is complete.",
  MIGRATING_TO_NOTES: "Migrating scheduling data to notes...",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: 'For more information, check the <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Folders to ignore",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Flashcards",
  FLASHCARD_EASY_LABEL: "Easy Button Text",
  FLASHCARD_GOOD_LABEL: "Good Button Text",
  FLASHCARD_HARD_LABEL: "Hard Button Text",
  FLASHCARD_AGAIN_LABEL: "Again Button Text",
  FLASHCARD_EASY_DESC: 'Customize the label for the "Easy" Button',
  FLASHCARD_GOOD_DESC: 'Customize the label for the "Good" Button',
  FLASHCARD_HARD_DESC: 'Customize the label for the "Hard" Button',
  FLASHCARD_AGAIN_DESC: 'Customize the label for the "Again" Button',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Flashcard tags",
  FLASHCARD_TAGS_DESC: "Enter tags separated by spaces or newlines i.e. #flashcards #deck2 #deck3.",
  FLASHCARD_TAGS_TO_IGNORE: "Tags to ignore",
  FLASHCARD_TAGS_TO_IGNORE_DESC: "Enter tags separated by spaces or newlines. Notes containing any of these tags will be excluded from flashcard review.",
  CONVERT_FOLDERS_TO_DECKS: "Convert folders to decks and subdecks",
  CONVERT_FOLDERS_TO_DECKS_DESC: "This is an alternative to the Flashcard tags option above.",
  INLINE_SCHEDULING_COMMENTS: "Save scheduling comment on the same line as the flashcard's last line?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Turning this on will make the HTML comments not break list formatting.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Bury sibling cards until the next day",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Siblings are cards generated from the same card text i.e. cloze deletions",
  SHOW_CARD_CONTEXT: "Show context in cards",
  SHOW_CARD_CONTEXT_DESC: "i.e. Title > Heading 1 > Subheading > ... > Subheading",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  SHOW_DELETE_BUTTON: "Show Delete button",
  SHOW_DELETE_BUTTON_DESC: "Adds a delete button to the card review UI.",
  CARD_MODAL_HEIGHT_PERCENT: "Flashcard Height Percentage",
  CARD_MODAL_SIZE_PERCENT_DESC: "Should be set to 100% on mobile or if you have very large images",
  RESET_DEFAULT: "Reset to default",
  CARD_MODAL_WIDTH_PERCENT: "Flashcard Width Percentage",
  RANDOMIZE_CARD_ORDER: "Randomize card order during review?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Order cards in a deck are displayed during review",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentially within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentially within a deck (All due cards first)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Randomly within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Randomly within a deck (All due cards first)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_DECK_ORDER: "Order decks are displayed during review",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentially (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Randomly (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_REMINDERS: "Review reminders",
  REVIEW_REMINDERS_DESC: "Periodically checks for new or due flashcards and reminds you when cards are ready to review.",
  REVIEW_REMINDER_CHECK_ON_STARTUP: "Check immediately on startup",
  REVIEW_REMINDER_CHECK_ON_STARTUP_DESC: "Runs one check when Obsidian startup layout is ready, without waiting for the first interval.",
  REVIEW_REMINDER_INTERVAL: "Reminder interval (minutes)",
  REVIEW_REMINDER_INTERVAL_DESC: "Checks every N minutes. Minimum 1 minute, maximum 1440 minutes.",
  REVIEW_REMINDER_INTERVAL_MIN_WARNING: "Reminder interval must be a number between 1 and 1440.",
  REVIEW_REMINDER_MESSAGE: "Reminder message",
  REVIEW_REMINDER_MESSAGE_DESC: "Optional custom message shown in the reminder notice. Leave empty to use the default message.",
  REVIEW_REMINDER_AUTO_OPEN: "Automatically open review",
  REVIEW_REMINDER_AUTO_OPEN_DESC: "When enabled, reminders open the existing flashcard review session directly.",
  REVIEW_REMINDER_SHOW_NOTICE: "Show notice when reminding",
  REVIEW_REMINDER_SHOW_NOTICE_DESC: "Displays a temporary notice when a review reminder fires.",
  REVIEW_REMINDER_PLAY_SOUND: "Play sound when reminding",
  REVIEW_REMINDER_PLAY_SOUND_DESC: "Plays a short alert sound when a review reminder fires.",
  REVIEW_REMINDER_BOUNCE_DOCK: "Bounce dock icon when reminding",
  REVIEW_REMINDER_BOUNCE_DOCK_DESC: "On desktop, bounces the dock icon when a review reminder fires.",
  DISABLE_CLOZE_CARDS: "Disable cloze cards?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "Convert ==highlights== to clozes",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'Add/remove the <code>${defaultPattern}</code> from your "Cloze Patterns"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "Convert **bolded text** to clozes",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'Add/remove the <code>${defaultPattern}</code> from your "Cloze Patterns"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "Convert {{curly brackets}} to clozes",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'Add/remove the <code>${defaultPattern}</code> from your "Cloze Patterns"',
  CLOZE_PATTERNS: "Cloze Patterns",
  CLOZE_PATTERNS_DESC: 'Enter cloze patterns separated by newlines. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Separator for inline flashcards",
  FIX_SEPARATORS_MANUALLY_WARNING: "Note that after changing this you have to manually edit any flashcards you already have.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Separator for inline reversed flashcards",
  MULTILINE_CARDS_SEPARATOR: "Separator for multiline flashcards",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Separator for multiline reversed flashcards",
  MULTILINE_CARDS_END_MARKER: "Characters denoting the end of clozes and multiline flashcards",
  NOTES: "Notes",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Enable note review pane on startup",
  TAGS_TO_REVIEW: "Tags to review",
  TAGS_TO_REVIEW_DESC: "Enter tags separated by spaces or newlines i.e. #review #tag2 #tag3.",
  NOTE_TAGS_TO_IGNORE: "Tags to ignore",
  NOTE_TAGS_TO_IGNORE_DESC: "Enter tags separated by spaces or newlines. Notes containing any of these tags will be excluded from note review.",
  OPEN_RANDOM_NOTE: "Open a random note for review",
  OPEN_RANDOM_NOTE_DESC: "When you turn this off, notes are ordered by importance (PageRank).",
  AUTO_NEXT_NOTE: "Open next note automatically after a review",
  MAX_N_DAYS_REVIEW_QUEUE: "Maximum number of days to display on note review panel",
  MIN_ONE_DAY: "The number of days must be at least 1.",
  VALID_NUMBER_WARNING: "Please provide a valid number.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  STATUS_BAR_SETTINGS: "Status Bar",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide all status messages in Obsidian's status bar",
  SHOW_CARD_STATUS_BAR_ITEM: "Show card status bar item",
  SHOW_CARD_STATUS_BAR_ITEM_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_NOTE_STATUS_BAR_ITEM: "Show note status bar item",
  SHOW_NOTE_STATUS_BAR_ITEM_DESC: "Turn this off to hide the note's review status in Obsidian's status bar",
  SHOW_UPDATE_AVAILABLE_STATUS_BAR_ITEM: "Show update available status bar item",
  SHOW_UPDATE_AVAILABLE_STATUS_BAR_ITEM_DESC: "Turn this off to hide the update available status bar item & to stop the fetching of the newest version number",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Enable the review options in the file menu (e.g. Review: Easy, Good, Hard)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "If you disable the review options in the file menu, you can review your notes using the plugin commands and, if you defined them, the associated command hotkeys.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Deck trees should be initially displayed as expanded",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Turn this off to collapse nested decks in the same card. Useful if you have cards which belong to many decks in the same file.",
  ALGORITHM: "Algorithm",
  CHECK_ALGORITHM_WIKI: 'For more information, check the <a href="${algoUrl}">algorithm details</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  SWITCH_TO_FSRS_ALGORITHM: "Switch flashcard algorithm to FSRS?",
  CONFIRM_FSRS_ALGORITHM_SWITCH: "Switching to FSRS may cause unforseen data loss, as it is still not tested enough! Switching changes how flashcard scheduling data is formatted as cards are reviewed. this means that rewritten cards in the FSRS format, will require a lot more parameters and thus a longer, more intrusive, scheduling data comment. There is best effort backwards compatibility for the scheduling comments, in case you might want to switch back to OSR. This means your scheduling data will be rewritten to the OSR format once you review a card with OSR enabled.",
  BASE_EASE: "Base ease",
  BASE_EASE_DESC: "minimum = 130, preferrably approximately 250.",
  BASE_EASE_MIN_WARNING: "The base ease must be at least 130.",
  LAPSE_INTERVAL_CHANGE: "Interval change when you review a flashcard/note as hard",
  LAPSE_INTERVAL_CHANGE_DESC: "newInterval = oldInterval * intervalChange / 100.",
  EASY_BONUS: "Easy Bonus",
  EASY_BONUS_DESC: "The easy bonus allows you to set the difference in intervals between answering Good and Easy on a flashcard/note (minimum = 100%).",
  EASY_BONUS_MIN_WARNING: "The easy bonus must be at least 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maximum interval in days",
  MAX_INTERVAL_DESC: "Allows you to place an upper limit on the interval (default = 100 years).",
  MAX_INTERVAL_MIN_WARNING: "The maximum interval must be at least 1 day.",
  MAX_LINK_CONTRIB: "Maximum link contribution",
  MAX_LINK_CONTRIB_DESC: "Maximum contribution of the weighted ease of linked notes to the initial ease.",
  LOGGING: "Logging",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Show the scheduler's debugging information on the developer console",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  USE_CUSTOM_HOTKEYS: "Use custom hotkeys",
  USE_CUSTOM_HOTKEYS_DESC: "Enable custom hotkeys for the review cards commands. The default hotkeys wont be active after enabling this. Custom hotkeys can only be used when using the 'Open in new tab' option.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Notes Review Queue",
  CLOSE: "Close",
  NEW: "New",
  YESTERDAY: "Yesterday",
  TODAY: "Today",
  TOMORROW: "Tomorrow",
  // stats-modal.tsx
  STATS_TITLE: "Statistics",
  MONTH: "Month",
  QUARTER: "Quarter",
  YEAR: "Year",
  LIFETIME: "Lifetime",
  FORECAST: "Forecast",
  FORECAST_DESC: "The number of cards due in the future",
  SCHEDULED: "Scheduled",
  DAYS: "Days",
  NUMBER_OF_CARDS: "Number of cards",
  REVIEWS_PER_DAY: "Average: ${avg} reviews/day",
  INTERVALS: "Intervals",
  INTERVALS_DESC: "Delays until reviews are shown again",
  COUNT: "Count",
  INTERVALS_SUMMARY: "Average interval: ${avg}, Longest interval: ${longest}",
  EASES: "Eases",
  EASES_SUMMARY: "Average ease: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Card Types",
  CARD_TYPES_DESC: "This includes buried cards as well, if any",
  CARD_TYPE_NEW: "New",
  CARD_TYPE_YOUNG: "Young",
  CARD_TYPE_MATURE: "Mature",
  CARD_TYPES_SUMMARY: "Total cards: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on any note to open it for review. To rate a review click on the 3 dots next to the note.",
  NOTE_REVIEW_QUEUE_EMPTY_HINT: "There are no notes to review. To add some notes, add the tag 'review' in one of your notes.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > Scheduling > Delete
  DELETE_SCHEDULING_DATA_IN_NOTES: "Delete Scheduling Data in Notes",
  DELETE_SCHEDULING_DATA_IN_NOTES_DESC: "Delete scheduling data from all notes.",
  DELETE_SCHEDULING_DATA_IN_CARDS: "Delete Scheduling Data in Cards",
  DELETE_SCHEDULING_DATA_IN_CARDS_DESC: "Delete scheduling data from all cards.",
  CONFIRM_SCHEDULING_DATA_IN_NOTES_DELETION: "Are you sure you want to delete all scheduling data from your notes? This action cannot be undone.",
  CONFIRM_SCHEDULING_DATA_IN_CARDS_DELETION: "Are you sure you want to delete all scheduling data from your cards? This action cannot be undone.",
  SCHEDULING_DATA_IN_NOTES_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_IN_CARDS_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.',
  OPEN_MENU: "Open menu",
  DELETE_NOTE_SCHEDULING_DATA_IN_NOTE: "Delete note scheduling data in note",
  CONFIRM_NOTE_SCHEDULING_DATA_IN_NOTE_DELETION: "Are you sure you want to delete note scheduling data in this note?",
  NOTE_SCHEDULING_DATA_IN_NOTE_DELETION_IN_PROGRESS: "Deleting note scheduling data in note...",
  DELETE_SCHEDULING_DATA_OF_CARDS_IN_NOTE: "Delete scheduling data of cards in note",
  CONFIRM_SCHEDULING_DATA_OF_CARDS_IN_NOTE_DELETION: "Are you sure you want to delete scheduling data of cards in note?",
  SCHEDULING_DATA_OF_CARDS_IN_NOTE_DELETION_IN_PROGRESS: "Deleting scheduling data of cards in note...",
  DELETE_TAGS_WHEN_DELETING_SCHEDULING_DATA: "Delete tags when deleting scheduling data",
  DELETE_TAGS_WHEN_DELETING_SCHEDULING_DATA_DESC: "Delete tags when deleting scheduling data",
  ENABLE_FILE_MENU_DELETE_BUTTON: "Enable file menu delete button",
  ENABLE_FILE_MENU_DELETE_BUTTON_DESC: "Enables the delete button in the file menu for scheduling data",
  DATA_PAGE_NAME: "Data",
  GROUP_RESET_SETTINGS: "Reset settings",
  GROUP_RESET_SETTINGS_DESC: "Reset all settings to their default values",
  RESET_SETTINGS: "Reset settings",
  CONFIRM_RESET_SETTINGS: "Are you sure you want to reset all settings to their default values?",
  RESET_SETTINGS_CONFIRMATION: "Resetting all settings to their default values...",
  DATE_FORMAT_FOR_NOTE_REVIEW_QUEUE: "Date format for note review queue",
  DATE_FORMAT_FOR_NOTE_REVIEW_QUEUE_DESC: 'Date format for note review queue (see <a href="${docsUrl}">moment.js</a> for details). It only updates, once the note review queue is reopened.',
  MIGRATE_TO_FOLDER: "Migrate to folder",
  CONFIRM_MIGRATE_TO_FOLDER: "Are you sure you want to migrate to folder storage?",
  MIGRATING_TO_FOLDER: "Migrating to folder storage...",
  USE_CALLOUTS_FOR_SCHEDULING_COMMENTS: "Use callouts for scheduling comments",
  USE_CALLOUTS_FOR_SCHEDULING_COMMENTS_DESC: "Use the sr metadata callout for scheduling comments instead of regular comments by default. This will hide away the scheduling comments in a callout which looks like an empty line in the editor.",
  MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT_BUTTON: "Migrate",
  MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT_DESC: "Migrating will put the scheduling comments into a sr metadata callout. This callout is designed to hide away the scheduling comments.",
  CONFIRM_MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT: "Migrating will modify all your cards. Please back them up first in case you want to revert the migration later or in case it breaks your cards because of a bug. Are you sure you want to migrate scheduling comments to sr metadata callouts?",
  MIGRATING_SCHEDULING_COMMENTS_TO_CALLOUT: "Migrating scheduling comments to sr metadata callouts...",
  MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT: "Migrate scheduling comments to sr metadata callout",
  DEFAULT_LOCALE_NAME: "- Obsidian's Default -",
  LANGUAGE_SETTINGS: "Language Settings",
  LANGUAGE_SETTINGS_DESC: "Select the language you want to use for the plugin interface. This will only fully take effect after restarting Obsidian.",
  DEBUG_LOG: "Debug Log",
  COPY: "Copy",
  NO_DECKS_TO_REVIEW: "There are no decks with cards to review. Make sure you have created some flashcards by adding the tag 'flashcards' to a note and then add cards to it (see plugin page for details on that). In case you did all that and still don't see any decks here, then it will probably caused by a bug in the plugin. There is a known bug that happens when one reviews the cards very fast, then the system bugs out and the decks are not shown. Please try again to open the deck list after a few seconds."
};
var en_default = en;

// src/lang/locale-manager.ts
var import_obsidian = require("obsidian");

// src/lang/locale/af.ts
var af = {
  ...en_default,
  language: "af",
  languageName: "Afrikaans"
};
var af_default = af;

// src/lang/locale/ar.ts
var ar = {
  ...en_default,
  language: "ar",
  languageName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
  // flashcard-modal.tsx
  DECKS: "\u0627\u0644\u0631\u064F\u0632\u0645\u064E\u0627\u062A",
  DUE_CARDS: "\u0628\u0637\u0627\u0642\u0627\u062A \u0645\u064F\u0633\u062A\u062D\u0642\u0629",
  NEW_CARDS: "\u0628\u0637\u0627\u0642\u0627\u062A \u062C\u062F\u064A\u062F\u0629",
  TOTAL_CARDS: "\u0625\u062C\u0645\u0627\u0644\u064A \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  BACK: "\u0631\u062C\u0648\u0639",
  EDIT_CARD: "\u062A\u0639\u062F\u064A\u0644 \u0627\u0644\u0628\u0637\u0627\u0642\u0629",
  RESET_CARD_PROGRESS: "\u0625\u0639\u0627\u062F\u0629 \u062A\u0639\u064A\u064A\u0646 \u062A\u0642\u062F\u0651\u064F\u0645\u0652 \u0627\u0644\u0628\u0637\u0627\u0642\u0629",
  HARD: "\u0635\u0639\u0628",
  GOOD: "\u062C\u064A\u062F",
  EASY: "\u0633\u0647\u0644",
  SHOW_ANSWER: "\u0623\u0638\u0647\u0650\u0631 \u0627\u0644\u0625\u062C\u0627\u0628\u0629",
  CARD_PROGRESS_RESET: ".\u062A\u0645\u0651\u064E\u062A \u0625\u0639\u0627\u062F\u0629 \u062A\u0639\u064A\u064A\u0646 \u062A\u0642\u062F\u0651\u064F\u0645 \u0627\u0644\u0628\u0637\u0627\u0642\u0629",
  SAVE: "\u062D\u0641\u0638",
  CANCEL: "\u0625\u0644\u063A\u0627\u0621",
  NO_INPUT: ".\u0644\u0645 \u064A\u062A\u0650\u0645 \u062A\u0642\u062F\u064A\u0645 \u0623\u064A \u0645\u064F\u062F\u062E\u0644\u0627\u062A",
  CURRENT_EASE_HELP_TEXT: ":\u0627\u0644\u0633\u0647\u0648\u0644\u0629 \u0627\u0644\u062D\u0627\u0644\u064A\u0629",
  CURRENT_INTERVAL_HELP_TEXT: ":\u0627\u0644\u0641\u0627\u0635\u0644 \u0627\u0644\u0632\u0645\u0646\u064A \u0627\u0644\u062D\u0627\u0644\u064A",
  CARD_GENERATED_FROM: "${notePath} :\u062A\u0645 \u0625\u0646\u0634\u0627\u0624\u0647\u0627 \u0645\u0646",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\u0627\u0641\u062A\u062D \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629 \u0644\u0644\u0645\u0631\u0627\u062C\u0639\u0629",
  REVIEW_CARDS: "\u0645\u0631\u0627\u062C\u0639\u0629 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  REVIEW_DIFFICULTY_FILE_MENU: "${difficulty} :\u0645\u0631\u0627\u062C\u0639\u0629",
  REVIEW_NOTE_DIFFICULTY_CMD: "${difficulty} \u0645\u0631\u0627\u062C\u0639\u0629 \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629 \u0643\u0640",
  CRAM_ALL_CARDS: "\u062D\u062F\u062F \u0631\u064F\u0632\u0645\u064E\u0629 \u0644\u0644\u062D\u0634\u0631",
  REVIEW_ALL_CARDS: "\u0645\u0631\u0627\u062C\u0639\u0629 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0645\u0646 \u062C\u0645\u064A\u0639 \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0627\u062A",
  REVIEW_CARDS_IN_NOTE: "\u0645\u0631\u0627\u062C\u0639\u0629 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A  \u0645\u0646 \u0647\u0630\u0647 \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629",
  CRAM_CARDS_IN_NOTE: "\u0623\u062D\u0634\u0631 \u062C\u0645\u064A\u0639 \u0628\u0637\u0627\u0642\u0627\u062A \u0647\u0630\u0647 \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629",
  VIEW_STATS: "\u0639\u0631\u0636 \u0627\u0644\u0625\u062D\u0635\u0627\u0626\u064A\u0627\u062A",
  STATUS_BAR: "\u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0645\u0633\u062A\u062D\u0642\u0629 ${dueFlashcardsCount},\u0645\u0644\u0627\u062D\u0638\u0627\u062A ${dueNotesCount}:\u0645\u0631\u0627\u062C\u0639\u0629",
  SYNC_TIME_TAKEN: "${t}ms \u0627\u0633\u062A\u063A\u0631\u0627\u0642 \u0627\u0644\u0645\u0632\u0627\u0645\u0646\u0629",
  NOTE_IN_IGNORED_FOLDER: ".\u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629 \u064A\u062A\u0645 \u062D\u0641\u0638\u0647\u0627 \u0636\u0645\u0646 \u0627\u0644\u0645\u062C\u0644\u062F \u0627\u0644\u0630\u064A \u062A\u0645 \u062A\u062C\u0627\u0647\u0644\u0647 (\u062A\u062D\u0642\u0642 \u0645\u0646 \u0627\u0644\u0625\u0639\u062F\u0627\u062F\u0627\u062A)",
  PLEASE_TAG_NOTE: ".\u064A\u0631\u062C\u0649 \u0648\u0636\u0639 \u0648\u0633\u0645 \u0639\u0644\u0649 \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629 \u0628\u0634\u0643\u0644 \u0645\u0646\u0627\u0633\u0628 \u0644\u0644\u0645\u0631\u0627\u062C\u0639\u0629 (\u0641\u064A \u0627\u0644\u0625\u0639\u062F\u0627\u062F\u0627\u062A)",
  RESPONSE_RECEIVED: ".\u0627\u0633\u062A\u064F\u0644\u0645\u062A \u0627\u0644\u0627\u0633\u062A\u062C\u0627\u0628\u0629",
  NO_DECK_EXISTS: "${deckName} \u0644\u0627 \u064A\u0648\u062C\u062F \u0631\u064F\u0632\u0645\u064E\u0629",
  ALL_CAUGHT_UP: "\u{1F606} \u0644\u0642\u062F \u062A\u0645 \u0627\u0644\u0642\u0628\u0636 \u0639\u0644\u064A\u0643\u0645 \u062C\u0645\u064A\u0639\u0627 \u0627\u0644\u0622\u0646",
  // scheduling.ts
  DAYS_STR_IVL: "\u064A\u0648\u0645/\u0623\u064A\u0627\u0645 ${interval}",
  MONTHS_STR_IVL: "\u0634\u0647\u0631/\u0623\u0634\u0647\u0631 ${interval}",
  YEARS_STR_IVL: "\u0633\u0646\u0629/\u0633\u0646\u0648\u0627\u062A ${interval}",
  DAYS_STR_IVL_MOBILE: "\u064A${interval}",
  MONTHS_STR_IVL_MOBILE: "\u0634${interval}",
  YEARS_STR_IVL_MOBILE: "\u0633${interval}",
  // settings.ts
  CHECK_WIKI: '.<a href="${wikiUrl}">wiki</a> \u0644\u0645\u0632\u064A\u062F \u0645\u0646 \u0627\u0644\u0645\u0639\u0644\u0648\u0645\u0627\u062A \u060C \u062A\u062D\u0642\u0642 \u0645\u0646',
  FOLDERS_TO_IGNORE: "\u0645\u062C\u0644\u062F\u0627\u062A \u0644\u062A\u062C\u0627\u0647\u0644\u0647\u0627",
  FLASHCARDS: "\u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  FLASHCARD_EASY_LABEL: "\u0646\u0635 \u0627\u0644\u0632\u0631 \u0633\u0647\u0644",
  FLASHCARD_GOOD_LABEL: "\u0646\u0635 \u0627\u0644\u0632\u0631 \u062C\u064A\u062F",
  FLASHCARD_HARD_LABEL: "\u0646\u0635 \u0627\u0644\u0632\u0631 \u0635\u0639\u0628",
  FLASHCARD_EASY_DESC: '"\u062A\u062E\u0635\u064A\u0635 \u0627\u0644\u062A\u0633\u0645\u064A\u0629 \u0644\u0644\u0632\u0631 "\u0633\u0647\u0644',
  FLASHCARD_GOOD_DESC: '"\u062A\u062E\u0635\u064A\u0635 \u0627\u0644\u062A\u0633\u0645\u064A\u0629 \u0644\u0644\u0632\u0631 "\u062C\u064A\u062F',
  FLASHCARD_HARD_DESC: '"\u062A\u062E\u0635\u064A\u0635 \u0627\u0644\u062A\u0633\u0645\u064A\u0629 \u0644\u0644\u0632\u0631 "\u0635\u0639\u0628',
  FLASHCARD_TAGS: "\u0648\u064F\u0633\u0648\u0645 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  FLASHCARD_TAGS_DESC: "#2\u0623\u062F\u062E\u0644 \u0627\u0644\u0648\u064F\u0633\u0648\u0645 \u0645\u0641\u0635\u0648\u0644\u0629 \u0628\u0645\u0633\u0627\u0641\u0627\u062A \u0623\u0648 \u0623\u0633\u0637\u0631 \u062C\u062F\u064A\u062F\u0629 \u060C \u0623\u064A \u0628\u0637\u0627\u0642\u0627\u062A# \u0631\u0632\u0645\u06293# \u0631\u0632\u0645\u0629",
  CONVERT_FOLDERS_TO_DECKS: "\u062A\u062D\u0648\u064A\u0644 \u0627\u0644\u0645\u062C\u0644\u062F\u0627\u062A \u0625\u0644\u0649 \u0645\u0644\u0641\u0627\u062A \u0623\u0635\u0644\u064A\u0629 \u0648 \u0645\u0644\u0641\u0627\u062A \u0627\u0644\u0641\u0631\u0639\u064A\u0629\u061F",
  CONVERT_FOLDERS_TO_DECKS_DESC: ".\u0647\u0630\u0627 \u0647\u0648 \u0628\u062F\u064A\u0644 \u0644\u062E\u064A\u0627\u0631 \u0648\u0633\u0648\u0645 \u0627\u0644\u0628\u0637\u0627\u0642\u0629 \u0623\u0639\u0644\u0627\u0647",
  INLINE_SCHEDULING_COMMENTS: "\u062D\u0641\u0638 \u062A\u0639\u0644\u064A\u0642 \u0627\u0644\u062C\u062F\u0648\u0644\u0629 \u0639\u0644\u0649 \u0646\u0641\u0633 \u0627\u0644\u0633\u0637\u0631 \u0645\u062B\u0644 \u0627\u0644\u0633\u0637\u0631 \u0627\u0644\u0623\u062E\u064A\u0631 \u0644\u0644\u0628\u0637\u0627\u0642\u0629 \u061F",
  INLINE_SCHEDULING_COMMENTS_DESC: "\u0644\u0627 \u062A\u0643\u0633\u0631 \u062A\u0646\u0633\u064A\u0642 \u0627\u0644\u0642\u0627\u0626\u0645\u0629 HTML \u0633\u064A\u0624\u062F\u064A \u062A\u0634\u063A\u064A\u0644 \u0647\u0630\u0627 \u0625\u0644\u0649 \u062C\u0639\u0644 \u062A\u0639\u0644\u064A\u0642\u0627\u062A",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\u0623\u062E\u0641\u064A \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0634\u0642\u064A\u0642\u0629 \u062D\u062A\u0649 \u0627\u0644\u064A\u0648\u0645 \u0627\u0644\u062A\u0627\u0644\u064A",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "cloze deletions : \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0634\u0642\u064A\u0642\u0629 \u0647\u064A \u0628\u0637\u0627\u0642\u0627\u062A \u062A\u0645 \u0625\u0646\u0634\u0627\u0624\u0647\u0627 \u0645\u0646 \u0646\u0641\u0633 \u0646\u0635 \u0627\u0644\u0628\u0637\u0627\u0642\u0629 \u0643\u0640",
  SHOW_CARD_CONTEXT: "\u0625\u0638\u0647\u0627\u0631 \u0627\u0644\u0633\u064A\u0627\u0642 \u0641\u064A \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A\u061F",
  CARD_MODAL_HEIGHT_PERCENT: "\u0646\u0633\u0628\u0629 \u0627\u0631\u062A\u0641\u0627\u0639 \u0627\u0644\u0628\u0637\u0627\u0642\u0629",
  CARD_MODAL_SIZE_PERCENT_DESC: "\u064A\u062C\u0628 \u0636\u0628\u0637\u0647\u0627 \u0639\u0644\u0649 100 \u066A \u0639\u0644\u0649 \u0627\u0644\u0647\u0627\u062A\u0641 \u0627\u0644\u0645\u062D\u0645\u0648\u0644 \u0623\u0648 \u0625\u0630\u0627 \u0643\u0627\u0646 \u0644\u062F\u064A\u0643 \u0635\u0648\u0631 \u0643\u0628\u064A\u0631\u0629 \u062C\u062F\u064B\u0627",
  RESET_DEFAULT: "\u0625\u0639\u0627\u062F\u0629 \u062A\u0639\u064A\u064A\u0646 \u0625\u0644\u0649 \u0627\u0644\u0627\u0641\u062A\u0631\u0627\u0636\u064A",
  CARD_MODAL_WIDTH_PERCENT: "\u0646\u0633\u0628\u0629 \u0639\u0631\u0636 \u0627\u0644\u0628\u0637\u0627\u0642\u0629",
  RANDOMIZE_CARD_ORDER: "\u062A\u0631\u062A\u064A\u0628 \u0628\u0637\u0627\u0642\u0629 \u0639\u0634\u0648\u0627\u0626\u064A \u0623\u062B\u0646\u0627\u0621 \u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0629\u061F",
  DISABLE_CLOZE_CARDS: "\u061Fcloze \u062A\u0639\u0637\u064A\u0644 \u0628\u0637\u0627\u0642\u0627\u062A",
  INLINE_CARDS_SEPARATOR: "\u0641\u0627\u0635\u0644 \u0645\u0646 \u0623\u062C\u0644 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0645\u0636\u0645\u0646\u0629",
  FIX_SEPARATORS_MANUALLY_WARNING: "\u0636\u0639 \u0641\u064A \u062D\u0633\u0627\u0628\u0643 \u0623\u0646\u0647 \u0628\u0639\u062F \u062A\u063A\u064A\u064A\u0631 \u0647\u0630\u0627 \u060C \u064A\u062C\u0628 \u0639\u0644\u064A\u0643 \u062A\u0639\u062F\u064A\u0644 \u0623\u064A \u0628\u0637\u0627\u0642\u0627\u062A \u0644\u062F\u064A\u0643 \u0628\u0627\u0644\u0641\u0639\u0644 \u064A\u062F\u0648\u064A\u064B\u0627",
  INLINE_REVERSED_CARDS_SEPARATOR: "\u0641\u0627\u0635\u0644 \u0645\u0646 \u0623\u062C\u0644 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0639\u0643\u0633\u064A\u0629 \u0627\u0644\u0645\u0636\u0645\u0646\u0629",
  MULTILINE_CARDS_SEPARATOR: "\u0641\u0627\u0635\u0644 \u0645\u0646 \u0623\u062C\u0644 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0645\u062A\u0639\u062F\u062F\u0629",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\u0641\u0627\u0635\u0644 \u0645\u0646 \u0623\u062C\u0644 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0639\u0643\u0633\u064A\u0629 \u0627\u0644\u0645\u062A\u0639\u062F\u062F\u0629",
  MULTILINE_CARDS_END_MARKER: "\u0627\u0644\u0623\u062D\u0631\u0641 \u0627\u0644\u062A\u064A \u062A\u062F\u0644 \u0639\u0644\u0649 \u0646\u0647\u0627\u064A\u0629 \u0627\u0644\u0643\u0644\u0648\u0632\u0627\u062A \u0648\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u062A\u0639\u0644\u0645 \u0627\u0644\u0645\u062A\u0639\u062F\u062F\u0629 \u0627\u0644\u0623\u0633\u0637\u0631",
  NOTES: "\u0645\u0644\u0627\u062D\u0638\u0627\u062A",
  REVIEW_PANE_ON_STARTUP: "\u062A\u0645\u0643\u064A\u0646 \u062C\u0632\u0621 \u0645\u0631\u0627\u062C\u0639\u0629 \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0627\u062A \u0639\u0646\u062F \u0628\u062F\u0621 \u0627\u0644\u062A\u0634\u063A\u064A\u0644",
  TAGS_TO_REVIEW: "\u0648\u0633\u0648\u0645 \u0644\u0644\u0645\u0631\u0627\u062C\u0639\u0629",
  TAGS_TO_REVIEW_DESC: "#\u0623\u062F\u062E\u0644 \u0627\u0644\u0648\u0633\u0648\u0645 \u0645\u0641\u0635\u0648\u0644\u0629 \u0628\u0645\u0633\u0627\u0641\u0627\u062A \u0623\u0648 \u062E\u0637\u0648\u0637 \u062C\u062F\u064A\u062F\u0629 \u060C \u0623\u064A : \u0645\u0631\u0627\u062C\u0639\u0629# \u0648\u0633\u06452# \u0648\u0633\u06453",
  OPEN_RANDOM_NOTE: "\u0627\u0641\u062A\u062D \u0645\u0644\u0627\u062D\u0638\u0629 \u0639\u0634\u0648\u0627\u0626\u064A\u0629 \u0644\u0644\u0645\u0631\u0627\u062C\u0639\u0629",
  OPEN_RANDOM_NOTE_DESC: "(Pagerank) \u0639\u0646\u062F \u062A\u0639\u0637\u064A\u0644 \u0647\u0630\u0627 \u0627\u0644\u062E\u064A\u0627\u0631 \u060C\u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0627\u062A \u0633\u064A\u062A\u0645 \u062A\u0631\u062A\u064A\u0628\u064F\u0647\u0627 \u062D\u0633\u0628 \u0627\u0644\u0623\u0647\u0645\u064A\u0629",
  AUTO_NEXT_NOTE: "\u0627\u0641\u062A\u062D \u0627\u0644\u0645\u0644\u0627\u062D\u0638\u0629 \u0627\u0644\u062A\u0627\u0644\u064A\u0629 \u062A\u0644\u0642\u0627\u0626\u064A\u064B\u0627 \u0628\u0639\u062F \u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0629",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\u0641\u0639\u0651\u0644 \u062E\u064A\u0627\u0631\u0627\u062A \u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0629 \u0641\u064A \u0642\u0627\u0626\u0645\u0629 \u0627\u0644\u0645\u0644\u0641 (\u0645\u062B\u0627\u0644: \u0645\u0631\u0627\u062C\u0639\u0629: \u0633\u0647\u0644\u060C \u062C\u064A\u062F\u060C \u0635\u0639\u0628)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\u0625\u0630\u0627 \u0642\u0645\u062A \u0628\u062A\u0639\u0637\u064A\u0644 \u062E\u064A\u0627\u0631\u0627\u062A \u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0629 \u0641\u064A \u0642\u0627\u0626\u0645\u0629 \u0627\u0644\u0645\u0644\u0641\u060C \u064A\u0645\u0643\u0646\u0643 \u0645\u0631\u0627\u062C\u0639\u0629 \u0645\u0644\u0627\u062D\u0638\u0627\u062A\u0643 \u0628\u0627\u0633\u062A\u062E\u062F\u0627\u0645 \u0623\u0648\u0627\u0645\u0631 \u0627\u0644\u0625\u0636\u0627\u0641\u0629 \u0648\u0625\u0630\u0627 \u0643\u0646\u062A \u0642\u062F \u062D\u062F\u062F\u062A\u0647\u0627\u060C \u0628\u0627\u0633\u062A\u062E\u062F\u0627\u0645 \u0645\u0641\u0627\u062A\u064A\u062D \u0627\u0644\u0627\u062E\u062A\u0635\u0627\u0631 \u0627\u0644\u0645\u0631\u062A\u0628\u0637\u0629.",
  MAX_N_DAYS_REVIEW_QUEUE: "\u0627\u0644\u062D\u062F \u0627\u0644\u0623\u0642\u0635\u0649 \u0644\u0639\u062F\u062F \u0627\u0644\u0623\u064A\u0627\u0645 \u0627\u0644\u062A\u064A \u064A\u062C\u0628 \u0639\u0631\u0636\u0647\u0627 \u0639\u0644\u0649 \u0627\u0644\u0644\u0648\u062D\u0629 \u0627\u0644\u064A\u0645\u0646\u0649",
  MIN_ONE_DAY: "\u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0639\u062F\u062F \u0627\u0644\u0623\u064A\u0627\u0645 1 \u0639\u0644\u0649 \u0627\u0644\u0623\u0642\u0644",
  VALID_NUMBER_WARNING: "\u064A\u0631\u062C\u0649 \u062A\u0642\u062F\u064A\u0645 \u0631\u0642\u0645 \u0635\u0627\u0644\u062D",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0627\u0644\u0639\u0631\u0636 \u0627\u0644\u0634\u062C\u0631\u064A \u0644\u0644\u0631\u064F\u0632\u0645 \u0645\u0648\u0633\u0639 \u0628\u062D\u064A\u062B \u062A\u0637\u0647\u0631 \u0627\u0644\u0645\u0644\u0641\u0627\u062A \u0627\u0644\u0641\u0631\u0639\u064A\u0629 \u0643\u0644\u0647\u0627",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: " \u0639\u0637\u0644 \u0647\u0630\u0627 \u0627\u0644\u062E\u064A\u0627\u0631 \u0644\u0637\u064A \u0627\u0644\u0631\u064F\u0632\u0645 \u0627\u0644\u0645\u062A\u062F\u0627\u062E\u0644\u0629 \u0641\u064A \u0646\u0641\u0633 \u0627\u0644\u0628\u0637\u0627\u0642\u0629 , \u0645\u0641\u064A\u062F \u0625\u0630\u0627 \u0643\u0627\u0646 \u0644\u062F\u064A\u0643 \u0628\u0637\u0627\u0642\u0627\u062A \u062A\u0646\u062A\u0645\u064A \u0625\u0644\u0649 \u0627\u0644\u0639\u062F\u064A\u062F \u0645\u0646 \u0627\u0644\u0631\u064F\u0632\u0645 \u0641\u064A \u0646\u0641\u0633 \u0627\u0644\u0645\u0644\u0641",
  ALGORITHM: "\u062E\u0648\u0627\u0631\u0632\u0645\u064A\u0629",
  CHECK_ALGORITHM_WIKI: '<a href="${algoUrl}">algorithm details</a> :\u0644\u0645\u0632\u064A\u062F \u0645\u0646 \u0627\u0644\u0645\u0639\u0644\u0648\u0645\u0627\u062A \u062A\u062D\u0642\u0642 \u0645\u0646',
  BASE_EASE: "\u0633\u0647\u0648\u0644\u0629 \u0627\u0644\u0642\u0627\u0639\u062F\u0629",
  BASE_EASE_DESC: "\u0627\u0644\u062D\u062F \u0627\u0644\u0623\u062F\u0646\u0649 = 130 \u060C \u0648\u064A\u0641\u0636\u0644 \u062D\u0648\u0627\u0644\u064A 250.",
  BASE_EASE_MIN_WARNING: "\u064A\u062C\u0628 \u0623\u0646 \u062A\u0643\u0648\u0646 \u0633\u0647\u0648\u0644\u0629 \u0627\u0644\u0642\u0627\u0639\u062F\u0629 130 \u0639\u0644\u0649 \u0627\u0644\u0623\u0642\u0644.",
  LAPSE_INTERVAL_CHANGE: "\u0627\u0644\u0641\u0627\u0635\u0644 \u0627\u0644\u0632\u0645\u0646\u064A \u064A\u062A\u063A\u064A\u0631 \u0639\u0646\u062F \u0645\u0631\u0627\u062C\u0639\u0629 \u0628\u0637\u0627\u0642\u0629/\u0645\u0644\u0627\u062D\u0638\u0629 \u0635\u0639\u0628\u0629",
  EASY_BONUS: "\u0645\u0643\u0627\u0641\u0623\u0629 \u0633\u0647\u0644\u0629",
  EASY_BONUS_DESC: "\u062A\u062A\u064A\u062D \u0644\u0643 \u0627\u0644\u0645\u0643\u0627\u0641\u0623\u0629 \u0627\u0644\u0633\u0647\u0644\u0629 \u0636\u0628\u0637 \u0627\u0644\u0641\u0631\u0642 \u0641\u064A \u0627\u0644\u0641\u0648\u0627\u0635\u0644 \u0627\u0644\u0632\u0645\u0646\u064A\u0629 \u0628\u064A\u0646 \u0627\u0644\u0631\u062F \u0627\u0644\u062C\u064A\u062F \u0648\u0627\u0644\u0633\u0647\u0644 \u0639\u0644\u0649 \u0628\u0637\u0627\u0642\u0629/\u0645\u0644\u0627\u062D\u0638\u0629 (\u0627\u0644\u062D\u062F \u0627\u0644\u0623\u062F\u0646\u0649 = 100 \u066A).",
  EASY_BONUS_MIN_WARNING: "\u064A\u062C\u0628 \u0623\u0646 \u062A\u0643\u0648\u0646 \u0627\u0644\u0645\u0643\u0627\u0641\u0623\u0629 \u0627\u0644\u0633\u0647\u0644\u0629 100 \u0639\u0644\u0649 \u0627\u0644\u0623\u0642\u0644.",
  MAX_INTERVAL_DESC: "\u064A\u062A\u064A\u062D \u0644\u0643 \u0648\u0636\u0639 \u062D\u062F \u0623\u0639\u0644\u0649  \u0644\u0644\u0641\u0627\u0635\u0644 \u0627\u0644\u0632\u0645\u0646\u064A (\u0627\u0641\u062A\u0631\u0627\u0636\u064A = 100 \u0639\u0627\u0645).",
  MAX_INTERVAL_MIN_WARNING: "\u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0627\u0644\u062D\u062F \u0627\u0644\u0623\u0642\u0635\u0649 \u0644\u0644\u0641\u0627\u0635\u0644 \u0627\u0644\u0632\u0645\u0646\u064A \u0644\u0645\u062F\u0629 \u064A\u0648\u0645 \u0648\u0627\u062D\u062F \u0639\u0644\u0649 \u0627\u0644\u0623\u0642\u0644.",
  MAX_LINK_CONTRIB: "\u0623\u0642\u0635\u0649 \u0645\u0633\u0627\u0647\u0645\u0629 \u0627\u0631\u062A\u0628\u0627\u0637",
  MAX_LINK_CONTRIB_DESC: "\u0623\u0642\u0635\u0649 \u0645\u0633\u0627\u0647\u0645\u0629 \u0644\u0644\u0633\u0647\u0648\u0644\u0629 \u0627\u0644\u0645\u0631\u062C\u062D\u0629 \u0644\u0644\u0645\u0644\u0627\u062D\u0638\u0627\u062A \u0627\u0644\u0645\u0631\u062A\u0628\u0637\u0629 \u0628\u0627\u0644\u0633\u0647\u0648\u0644\u0629 \u0627\u0644\u0623\u0648\u0644\u064A\u0629.",
  LOGGING: "\u062A\u0633\u062C\u064A\u0644",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\u0639\u0631\u0636 \u0645\u0639\u0644\u0648\u0645\u0627\u062A \u0627\u0644\u062A\u0635\u062D\u064A\u062D \u0639\u0644\u0649 \u0648\u062D\u062F\u0629 \u062A\u062D\u0643\u0645 \u0627\u0644\u0645\u0637\u0648\u0631",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\u0645\u0644\u0627\u062D\u0638\u0627\u062A \u0642\u0627\u0626\u0645\u0629 \u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0629",
  CLOSE: "\u0623\u063A\u0644\u0642",
  NEW: "\u062C\u062F\u064A\u062F",
  YESTERDAY: "\u0627\u0644\u0628\u0627\u0631\u062D\u0629",
  TODAY: "\u0627\u0644\u064A\u0648\u0645",
  TOMORROW: "\u0627\u0644\u063A\u062F",
  // stats-modal.tsx
  STATS_TITLE: "\u0625\u062D\u0635\u0627\u0626\u064A\u0627\u062A",
  MONTH: "\u0634\u0647\u0631",
  QUARTER: "\u0631\u0628\u0639 \u0627\u0644\u0633\u0646\u0629",
  YEAR: "\u0633\u0646\u0629",
  LIFETIME: "",
  FORECAST: "",
  FORECAST_DESC: "\u0639\u062F\u062F \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0645\u0633\u062A\u062D\u0642\u0629 \u0641\u064A \u0627\u0644\u0645\u0633\u062A\u0642\u0628\u0644",
  SCHEDULED: "\u0627\u0644\u0645\u0642\u0631\u0631",
  DAYS: "\u0623\u064A\u0627\u0645",
  NUMBER_OF_CARDS: "\u0639\u062F\u062F \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  REVIEWS_PER_DAY: "\u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0627\u062A/\u0627\u0644\u064A\u0648\u0645 ${avg} :\u0645\u062A\u0648\u0633\u0637",
  INTERVALS: "\u0641\u0648\u0627\u0635\u0644 \u0632\u0645\u0646\u064A\u0629",
  INTERVALS_DESC: "\u0627\u0644\u062A\u0623\u062E\u064A\u0631 \u062D\u062A\u0649 \u064A\u062A\u0645 \u0639\u0631\u0636 \u0627\u0644\u0645\u0631\u0627\u062C\u0639\u0627\u062A \u0645\u0631\u0629 \u0623\u062E\u0631\u0649",
  COUNT: "\u0639\u062F\u062F",
  INTERVALS_SUMMARY: "${longest} : \u0623\u0637\u0648\u0644 \u0641\u0627\u0635\u0644 \u0632\u0645\u0646\u064A ,${avg} :\u0645\u062A\u0648\u0633\u0637 \u0627\u0644\u0641\u0627\u0635\u0644 \u0627\u0644\u0632\u0645\u0646\u064A",
  EASES: "\u0627\u0644\u0633\u0647\u0648\u0644\u0629",
  EASES_SUMMARY: "${avgEase} :\u0645\u062A\u0648\u0633\u0637 \u0627\u0644\u0633\u0647\u0648\u0644\u0629",
  EASE: "Ease",
  CARD_TYPES: "\u0623\u0646\u0648\u0627\u0639 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  CARD_TYPES_DESC: "\u0648\u0647\u0630\u0627 \u064A\u0634\u0645\u0644 \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A \u0627\u0644\u0645\u062E\u0641\u064A\u0629 \u0643\u0630\u0644\u0643 \u060C \u0625\u0646 \u0648\u062C\u062F\u062A",
  CARD_TYPE_NEW: "\u062C\u062F\u064A\u062F\u0629",
  CARD_TYPE_YOUNG: "\u0635\u063A\u064A\u0631\u0629",
  CARD_TYPE_MATURE: "\u0646\u0627\u0636\u062C\u0629",
  CARD_TYPES_SUMMARY: " ${totalCardsCount} :\u0625\u062C\u0645\u0627\u0644\u064A \u0639\u062F\u062F \u0627\u0644\u0628\u0637\u0627\u0642\u0627\u062A",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var ar_default = ar;

// src/lang/locale/bn.ts
var bn = {
  ...en_default,
  language: "bn",
  languageName: "Bengali"
};
var bn_default = bn;

// src/lang/locale/cz.ts
var cz = {
  ...en_default,
  language: "cz",
  languageName: "\u010Ce\u0161tina",
  // flashcard-modal.tsx
  DECKS: "Bal\xED\u010Dky",
  DUE_CARDS: "Karti\u010Dky po term\xEDnu",
  NEW_CARDS: "Nov\xE9 karti\u010Dky",
  TOTAL_CARDS: "Karti\u010Dek celkem",
  BACK: "Back",
  SKIP: "Skip",
  EDIT_CARD: "Edit Card",
  RESET_CARD_PROGRESS: "Vynulovat pokrok karti\u010Dky",
  HARD: "T\u011B\u017Ek\xE9",
  GOOD: "Dobr\xE9",
  EASY: "Jednoduch\xE9",
  SHOW_ANSWER: "Uk\xE1zat odpov\u011B\u010F",
  CARD_PROGRESS_RESET: "Pokrok karti\u010Dky byl vynulov\xE1n.",
  SAVE: "Save",
  CANCEL: "Cancel",
  NO_INPUT: "No input provided.",
  CURRENT_EASE_HELP_TEXT: "Current Ease: ",
  CURRENT_INTERVAL_HELP_TEXT: "Current Interval: ",
  CARD_GENERATED_FROM: "Generated from: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Otev\u0159\xEDt pozn\xE1mku k revizi",
  REVIEW_CARDS: "Pozn\xE1mek k revizi",
  REVIEW_DIFFICULTY_FILE_MENU: "Revize: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Ozna\u010Dit pozn\xE1mku jako ${difficulty}",
  REVIEW_ALL_CARDS: "Revidovat karti\u010Dky ve v\u0161ech pozn\xE1mk\xE1ch",
  CRAM_ALL_CARDS: "Select a deck to cram",
  REVIEW_CARDS_IN_NOTE: "Revidovat karti\u010Dky v t\xE9to pozn\xE1mce.",
  CRAM_CARDS_IN_NOTE: "Cram karti\u010Dky v t\xE9to pozn\xE1mce.",
  VIEW_STATS: "Uk\xE1zat statistiky",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "Revize: ${dueNotesCount} pozn\xE1mek, ${dueFlashcardsCount} karti\u010Dek po term\xEDnu",
  SYNC_TIME_TAKEN: "Synchronizace trvala ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "Pozn\xE1mka je ulo\u017Eena v ignorovan\xE9 slo\u017Ece (zkontrolujte nastaven\xED).",
  PLEASE_TAG_NOTE: "Pros\xEDm ozna\u010Dne pozn\xE1mku odpov\xEDdaj\xEDc\xEDm tagem pro revizi (v nastaven\xED).",
  RESPONSE_RECEIVED: "Odpov\u011B\u010F p\u0159ijata.",
  NO_DECK_EXISTS: "Neexistuje \u017E\xE1dn\xFD bal\xED\u010Dek pro ${deckName}",
  ALL_CAUGHT_UP: "V\u0161e zrevidov\xE1no",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} den/dn\xED",
  MONTHS_STR_IVL: "${interval} m\u011Bs\xEDc(\u016F)",
  YEARS_STR_IVL: "${interval} rok(\u016F)",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}r",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: 'Pro v\xEDce informac\xED jd\u011Bte na <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Ignorovan\xE9 slo\u017Eky",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Karti\u010Dky",
  FLASHCARD_EASY_LABEL: "Easy Button Text",
  FLASHCARD_GOOD_LABEL: "Good Button Text",
  FLASHCARD_HARD_LABEL: "Hard Button Text",
  FLASHCARD_EASY_DESC: 'Customize the label for the "Easy" Button',
  FLASHCARD_GOOD_DESC: 'Customize the label for the "Good" Button',
  FLASHCARD_HARD_DESC: 'Customize the label for the "Hard" Button',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Tag pro karti\u010Dky",
  FLASHCARD_TAGS_DESC: "Zadete tagy ood\u011Blen\xE9 mezerou nebo od\u0159\xE1dkov\xE1n\xEDm nap\u0159\xEDklad. #karti\u010Dky #bal\xED\u010Dke2 #bal\xED\u010Dek3.",
  CONVERT_FOLDERS_TO_DECKS: "P\u0159ev\xE9st slo\u017Eky na bal\xED\u010Dky a podbal\xED\u010Dky?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Toto je alternativa k tag\u016Fm karti\u010Dek viz nastaven\xED v\xFD\u0161e.",
  INLINE_SCHEDULING_COMMENTS: "Ulo\u017Eit pl\xE1novac\xED koment\xE1\u0159 na stejn\xFD \u0159\xE1dek jako posledn\xED polo\u017Eka karti\u010Dky?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Zapnut\xED t\xE9to volby zp\u016Fsob\xED, \u017Ee HTML koment\xE1\u0159e nebudou rozb\xEDjet form\xE1tov\xE1n\xED list\u016F.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Odlo\u017Eit p\u0159\xEDbuzn\xE9 karti\u010Dky na dal\u0161\xED den?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "P\u0159\xEDbuzn\xE9 karti\u010Dky jsou karti\u010Dky generovan\xE9 z textu stejn\xE9 pozn\xE1mky nap\u0159\xEDklad cloze smaz\xE1n\xED",
  SHOW_CARD_CONTEXT: "Uk\xE1zat kontext v karti\u010Dce?",
  SHOW_CARD_CONTEXT_DESC: "nap\u0159\xEDklad Titulek > Nadpis1 > Podnadpis > ... > Podnadpis",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "V\xFD\u0161ka karti\u010Dek v procentech",
  CARD_MODAL_SIZE_PERCENT_DESC: "M\u011Blo by b\xFDt nastaveno na 100% na mobilu nebo kdy\u017E pou\u017E\xEDv\xE1te velk\xE9 obr\xE1zky",
  RESET_DEFAULT: "Resetovat v\xFDchoz\xED nastaven\xED",
  CARD_MODAL_WIDTH_PERCENT: "\u0160\xED\u0159ka karti\u010Dek v procentech",
  RANDOMIZE_CARD_ORDER: "N\xE1hodn\u011B zm\u011Bnit po\u0159ad\xED karti\u010Dek b\u011Bhem revize?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Order cards in a deck are displayed during review",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentially within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentially within a deck (All due cards first)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Randomly within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Randomly within a deck (All due cards first)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_DECK_ORDER: "Order decks are displayed during review",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentially (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Randomly (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  DISABLE_CLOZE_CARDS: "Vypnout cloze karti\u010Dky?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "P\u0159ev\xE9st ==zv\xFDrazn\u011Bn\xED== na clozes?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'P\u0159idat/odstranit <code>${defaultPattern}</code> z va\u0161ich "Cloze vzor\u016F"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "P\u0159ev\xE9st **tu\u010Dn\xFD text** na clozes?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'P\u0159idat/odstranit <code>${defaultPattern}</code> z va\u0161ich "Cloze vzor\u016F"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "P\u0159ev\xE9st {{slo\u017Een\xE9 z\xE1vorky}} na clozes?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'P\u0159idat/odstranit <code>${defaultPattern}</code> z va\u0161ich "Cloze vzor\u016F"',
  CLOZE_PATTERNS: "Cloze vzory",
  CLOZE_PATTERNS_DESC: 'Zadejte cloze vzory odd\u011Blen\xE9 od\u0159\xE1dkov\xE1n\xEDm. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Odd\u011Blova\u010D pro inline karti\u010Dky",
  FIX_SEPARATORS_MANUALLY_WARNING: "Pozor. Jakmile toto zm\u011Bn\xEDte, budete muset ru\u010Dn\u011B upravit v\u0161echny existuj\xEDc\xED karti\u010Dky.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Odd\u011Blova\u010D pro oto\u010Den\xE9 inline karti\u010Dky",
  MULTILINE_CARDS_SEPARATOR: "Odd\u011Blova\u010D pro v\xEDce\u0159\xE1dkov\xE9 karti\u010Dky",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Odd\u011Blova\u010D pro v\xEDce\u0159\xE1dkove oto\u010Den\xE9 karti\u010Dky",
  MULTILINE_CARDS_END_MARKER: "Znaky ozna\u010Duj\xEDc\xED konec clozes a v\xEDce\u0159\xE1dkov\xFDch flash karet",
  NOTES: "Pozn\xE1mky",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Enable note review pane on startup",
  TAGS_TO_REVIEW: "Tag pro revizi",
  TAGS_TO_REVIEW_DESC: "Zadejte tagy odd\u011Blen\xE9 mezerami nebo od\u0159\xE1dkov\xE1n\xEDm nap\u0159\xEDklad #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "Otev\u0159\xEDt n\xE1hodnou pozn\xE1mku pro revizi",
  OPEN_RANDOM_NOTE_DESC: "Pokud toto vypnete, pozn\xE1mky budou \u0159azeny dle d\u016Fle\u017Eitosti (PageRank).",
  AUTO_NEXT_NOTE: "Otev\u0159\xEDt automaticky dal\u0161\xED pozn\xE1mku po dokon\u010Den\xED revize",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Povolte mo\u017Enosti revize v nab\xEDdce souboru (nap\u0159. Revize: Jednoduch\xE9, Dobr\xE9, T\u011B\u017Ek\xE9)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Pokud v nab\xEDdce souboru zak\xE1\u017Eete mo\u017Enosti revize, m\u016F\u017Eete sv\xE9 pozn\xE1mky revidovat pomoc\xED p\u0159\xEDkaz\u016F pluginu a, pokud jste je definovali, pomoc\xED p\u0159i\u0159azen\xFDch kl\xE1vesov\xFDch zkratek.",
  MAX_N_DAYS_REVIEW_QUEUE: "Maxim\xE1ln\xED po\u010Det dn\xED zobrazen\xFDch v prav\xE9m panelu",
  MIN_ONE_DAY: "Po\u010Det dn\xED mus\xED b\xFDt minim\xE1ln\u011B 1.",
  VALID_NUMBER_WARNING: "Pros\xEDm zadejte validn\xED \u010D\xEDslo.",
  UI: "P\u0159edvolby u\u017Eivatelsk\xE9ho rozhran\xED",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Stromy bal\xED\u010Dky by m\u011Bly b\xFDt zpo\u010D\xE1tku zobrazeny jako rozbalen\xE9",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Vypn\u011Bte toto, chcete-li sbalit vno\u0159en\xE9 bal\xED\u010Dky na stejn\xE9 kart\u011B. To je u\u017Eite\u010Dn\xE9, pokud m\xE1te karti\u010Dky, kter\xE9 pat\u0159\xED k mnoha bal\xED\u010Dk\u016Fm ve stejn\xE9m souboru.",
  ALGORITHM: "Algoritmus",
  CHECK_ALGORITHM_WIKI: 'Pro v\xEDce informac\xED jd\u011Bte na <a href="${algoUrl}">popis algoritmu</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Z\xE1kladn\xED slo\u017Eitost",
  BASE_EASE_DESC: "minimum = 130, nejl\xE9pe p\u0159ibli\u017En\u011B 250.",
  BASE_EASE_MIN_WARNING: "Z\xE1kladn\xED slo\u017Eitost mus\xED b\xFDt minim\xE1ln\u011B 130.",
  LAPSE_INTERVAL_CHANGE: "Zm\u011Bna intervalu pokud karti\u010Dku/pozn\xE1mku ozna\u010D\xEDte jako slo\u017Eitou",
  LAPSE_INTERVAL_CHANGE_DESC: "nov\xFD_inteval = star\xFD_interval * zm\u011Bna_intevalu / 100.",
  EASY_BONUS: "Bonus pro jednoduch\xE9",
  EASY_BONUS_DESC: "Tento bonus umo\u017E\u0148uje nastavit rozd\xEDl intervalu mezi jednoduch\xFDmi a dobr\xFDmi karti\u010Dkami/pozn\xE1mkami (minimum = 100%).",
  EASY_BONUS_MIN_WARNING: "Bonus pro jednoduchost mus\xED b\xFDt minim\xE1ln\u011B 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maximum interval in days",
  MAX_INTERVAL_DESC: "Umo\u017E\u0148uje nastavit horn\xED limit pro interval (defaultn\u011B = 100 let).",
  MAX_INTERVAL_MIN_WARNING: "Maxim\xE1ln\xED interval mus\xED b\xFDt alespo\u0148 1 den.",
  MAX_LINK_CONTRIB: "Maxim\xE1ln\xED p\u0159\xEDsp\u011Bv\u011Bk prolinkov\xE1n\xED",
  MAX_LINK_CONTRIB_DESC: "Maxim\xE1ln\xED p\u0159\xEDsp\u011Bvek v\xE1\u017Een\xE9 slo\u017Eitosti prolinkovan\xFDch pozn\xE1mek pou\u017Eit\xFD pro ur\u010Den\xED po\u010D\xE1te\u010Dn\xED slo\u017Eitosti.",
  LOGGING: "Zaznamen\xE1v\xE1m",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Zobrazit informace pro lad\u011Bn\xED na v\xFDvoj\xE1\u0159sk\xE9 konzoli",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Fronta pozn\xE1mek k revizi",
  CLOSE: "Uzav\u0159en\xE9",
  NEW: "Nov\xE9",
  YESTERDAY: "V\u010Dera",
  TODAY: "Dnes",
  TOMORROW: "Z\xEDtra",
  // stats-modal.tsx
  STATS_TITLE: "Statistiky",
  MONTH: "M\u011Bs\xEDc",
  QUARTER: "\u010Ctvrtlet\xED",
  YEAR: "Rok",
  LIFETIME: "Celkov\u011B",
  FORECAST: "P\u0159edpov\u011B\u010F",
  FORECAST_DESC: "Celkov\xFD po\u010Det karti\u010Dek, kter\xFDm vypr\u0161\xED term\xEDn",
  SCHEDULED: "Napl\xE1nov\xE1no",
  DAYS: "Dn\xED",
  NUMBER_OF_CARDS: "Po\u010Det karti\u010Dek",
  REVIEWS_PER_DAY: "Pr\u016Fm\u011Br: ${avg} revize/den",
  INTERVALS: "Intervaly",
  INTERVALS_DESC: "Doba, za kterou bude znovu zobrazeno k revize",
  COUNT: "Po\u010Det",
  INTERVALS_SUMMARY: "Pr\u016Fm\u011Brn\xFD interval: ${avg}, Nejdel\u0161\xED interval: ${longest}",
  EASES: "Slo\u017Eitost",
  EASES_SUMMARY: "Pr\u016Fm\u011Brn\xE1 slo\u017Eitost: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Typy karti\u010Dek",
  CARD_TYPES_DESC: "Obsahuje i odlo\u017Een\xE9 karti\u010Dky (pokud existuj\xED)",
  CARD_TYPE_NEW: "Nov\xE1",
  CARD_TYPE_YOUNG: "Mlad\xE1",
  CARD_TYPE_MATURE: "Dosp\u011Bl\xE1",
  CARD_TYPES_SUMMARY: "Karti\u010Dek celkem: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var cz_default = cz;

// src/lang/locale/da.ts
var dn = {
  ...en_default,
  language: "da",
  languageName: "Dansk"
};
var da_default = dn;

// src/lang/locale/de.ts
var de = {
  ...en_default,
  language: "de",
  languageName: "Deutsch",
  // flashcard-modal.tsx
  DECKS: "Stapel",
  DUE_CARDS: "Anstehende Karten",
  NEW_CARDS: "Neue Karten",
  TOTAL_CARDS: "Alle Karten",
  BACK: "Zur\xFCck",
  SKIP: "\xDCberspringen",
  EDIT_CARD: "Karte bearbeiten",
  RESET_CARD_PROGRESS: "Kartenfortschritt zur\xFCcksetzten",
  HARD: "Schwer",
  GOOD: "Gut",
  EASY: "Einfach",
  SHOW_ANSWER: "Zeige Antwort",
  CARD_PROGRESS_RESET: "Kartenfortschritt wurde zur\xFCckgesetzt.",
  SAVE: "Speichern",
  CANCEL: "Abbrechen",
  NO_INPUT: "Keine Eingabe erhalten.",
  CURRENT_EASE_HELP_TEXT: "Aktuelle Schwierigkeit: ",
  CURRENT_INTERVAL_HELP_TEXT: "Aktueller Intervall: ",
  CARD_GENERATED_FROM: "Erstellt von: ${notePath}",
  VIEW_CARD_INFO: "Karteninformationen anzeigen",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Notiz zur Wiederholung \xF6ffnen",
  REVIEW_CARDS: "Lernkarten wiederholen",
  REVIEW_DIFFICULTY_FILE_MENU: "Notizen wiederholen als: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Notizen wiederholen als: ${difficulty}",
  REVIEW_ALL_CARDS: "Alle Lernkarten wiederholen",
  CRAM_ALL_CARDS: "W\xE4hle ein Stapel zum pauken",
  REVIEW_CARDS_IN_NOTE: "Lernkarten in dieser Notiz wiederholen",
  CRAM_CARDS_IN_NOTE: "Lernkarten in dieser Notiz pauken.",
  VIEW_STATS: "Statistiken anzeigen",
  OPEN_REVIEW_QUEUE_VIEW: "\xD6ffne \xDCberpr\xFCfungswarteschlage in der Seitenleiste",
  STATUS_BAR: "Wiederholung: ${dueNotesCount} Notiz(en), ${dueFlashcardsCount} Karte(n) anstehend",
  SYNC_TIME_TAKEN: "Synchronisierung dauerte ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "Notiz befindet sich in einem ausgeschlossenen Ordner (siehe Einstellungen).",
  PLEASE_TAG_NOTE: "Bitte die Notiz f\xFCr Wiederholungen entsprechend taggen (siehe Einstellungen).",
  RESPONSE_RECEIVED: "Antwort erhalten.",
  NO_DECK_EXISTS: "Kein Stapel f\xFCr ${deckName} gefunden.",
  ALL_CAUGHT_UP: "Yuhu! Alles geschafft! :D.",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} Tag(e)",
  MONTHS_STR_IVL: "${interval} Monat(e)",
  YEARS_STR_IVL: "${interval} Jahr(e)",
  DAYS_STR_IVL_MOBILE: "${interval}t",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}j",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Ordner",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Helfen",
  CHECK_WIKI: 'Weitere Informationen gibt es im <a href="${wikiUrl}">Wiki</a> (english).',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Ausgeschlossene Ordner",
  FOLDERS_TO_IGNORE_DESC: "Geben Sie Pfad- oder Globalemuster in separaten Zeilen an, z.B. Templates/Scripts oder **/*.excalidraw.md. Diese Einstellung gilt f\xFCr Flashcards und Notizen.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Lernkarten",
  FLASHCARD_EASY_LABEL: "Einfach Knopf Text",
  FLASHCARD_GOOD_LABEL: "Gut Knopf Text",
  FLASHCARD_HARD_LABEL: "Schwer Knopf Text",
  FLASHCARD_GOOD_DESC: 'Passe die Beschriftung f\xFCr "Gut" Knopf an',
  FLASHCARD_EASY_DESC: 'Passe die Beschriftung f\xFCr "Einfach" Knopf an',
  FLASHCARD_HARD_DESC: 'Passe die Beschriftung f\xFCr "Schwer" Knopf an',
  REVIEW_BUTTON_DELAY: "Druckknopfverz\xF6gerung (ms)",
  REVIEW_BUTTON_DELAY_DESC: "F\xFCgt den \xDCberpr\xFCfungsschaltfl\xE4chen (\u201EEinfach\u201C, \u201EGut\u201C, \u201ESchwer\u201C, \u201EAntwort anzeigen\u201C) eine Verz\xF6gerung hinzu, bevor sie erneut gedr\xFCckt werden k\xF6nnen.",
  FLASHCARD_TAGS: "Lernkarten Tags",
  FLASHCARD_TAGS_DESC: "Mehrere Tags mit Leerzeichen oder Zeilenumbr\xFCchen getrennt angeben. Bsp. #karte #stapel2 #stapel3.",
  CONVERT_FOLDERS_TO_DECKS: "Ordner in Stapel und Substapel umwandeln?",
  CONVERT_FOLDERS_TO_DECKS_DESC: 'Eine Alternative zur oberen "Lernkarten Tags" Option.',
  INLINE_SCHEDULING_COMMENTS: "Den Fortschritt in der gleichen Zeile wie die letzte Zeile einer Lernkartei speichern?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Wenn aktiviert, wird der HTML Kommentar die umgebende Liste nicht aufbrechen.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Verwandte Karten auf den n\xE4chsten Tag verlegen?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Verwandte Karten sind aus der gleichen Karte generiert worden (z.B. L\xFCckentextkarten oder beidseitige Karten).",
  SHOW_CARD_CONTEXT: "Kontext in den Karten anzeigen?",
  SHOW_CARD_CONTEXT_DESC: "Bsp. Titel > \xDCberschrift 1 > Sektion > ... > Untersektion",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Zeige n\xE4chsten Review-Zeit in den Review-Buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "H\xF6he der Lernkartei in Prozent",
  CARD_MODAL_SIZE_PERCENT_DESC: "Auf kleinen Bildschirmen (z.B. Smartphones) oder bei sehr grossen Bildern sollte dieser Wert auf 100% gesetzt werden.",
  RESET_DEFAULT: "Standardeinstellung wiederherstellen",
  CARD_MODAL_WIDTH_PERCENT: "Breite einer Lernkarte in Prozent",
  RANDOMIZE_CARD_ORDER: "W\xE4hrend der Wiederhoung die Reihenfolge zuf\xE4llig mischen?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Reihenfolge der Karten innerhalb eines Stapels w\xE4hrend der Wiederholung",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentielle Reihenfolge innerhalb eines Stapels (Alle neuen Karten zuerst)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentielle Reihenfolge innerhalb eines Stapels (Alle f\xE4lligen Karten zuerst)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Zuf\xE4llige Reihenfolge innerhalb eines Stapels (Alle neuen Karten zuerst)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Zuf\xE4llige Reihenfolge innerhalb eines Stapels (Alle f\xE4lligen Karten zuerst)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Zuf\xE4llige Karte von zuf\xE4lligem Stapel",
  REVIEW_DECK_ORDER: "Reihenfolge der Stapel w\xE4hrend der Wiederholung",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentielle Reihenfolge (sobald alle Karten im vorherigen Stapel wiederholt wurden)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Zuf\xE4llige Reihenfolge (sobald alle Karten im vorherigen Stapel wiederholt wurden)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Zuf\xE4llige Karte von zuf\xE4lligem Stapel",
  DISABLE_CLOZE_CARDS: "L\xFCckentextkarten deaktivieren?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Konvertiere L\xFCckentext zu Eingabefelder",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Ersetze L\xFCckentext mit Eingabefeldern, wenn L\xFCckentextkarten angezeigt werden.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "==Hervorgehobenen== Text in L\xFCckentextkarten umwandeln?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'F\xFCge/entferne das <code>${defaultPattern}</code> zu deinen "L\xFCckentextmuster" hinzu',
  CONVERT_BOLD_TEXT_TO_CLOZES: "**Fettgedruckten** Text in L\xFCckentextkarten umwandeln?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'F\xFCge/entferne das <code>${defaultPattern}</code> zu deinen "L\xFCckentextmuster" hinzu',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "{{Geschweifte Klammern}} Text in L\xFCckentextkarten umwandeln?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'F\xFCge/entferne das <code>${defaultPattern}</code> zu deinen "L\xFCckentextmuster" hinzu',
  CLOZE_PATTERNS: "L\xFCckentextmuster",
  CLOZE_PATTERNS_DESC: 'Geben Sie L\xFCckentextmuster durch Zeilenumbr\xFCche getrennt ein. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Trennzeichen f\xFCr einzeilige Lernkarten",
  FIX_SEPARATORS_MANUALLY_WARNING: "Wenn diese Einstellung ge\xE4ndert wird, dann m\xFCssen die entsprechenden Lernkarten manuell angepasst werden.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Trennzeichen f\xFCr einzeilige beidseitige Lernkarten",
  MULTILINE_CARDS_SEPARATOR: "Trennzeichen f\xFCr mehrzeilige Lernkarten",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Trennzeichen f\xFCr mehrzeilige beidseitige Lernkarten",
  MULTILINE_CARDS_END_MARKER: "Zeichen, die das Ende von L\xFCckentexten und mehrzeiligen Flashcards kennzeichnen",
  NOTES: "Notizen",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "\xD6ffne \xDCberpr\xFCfungswarteschlage beim start",
  TAGS_TO_REVIEW: "Zu wiederholende Tags",
  TAGS_TO_REVIEW_DESC: "Mehrere Tags k\xF6nnen mit Leerzeichen oder Zeilenumbr\xFCchen getrennt angegeben werden. Bsp. #karte #tag1 #tag2.",
  OPEN_RANDOM_NOTE: "Zuf\xE4llige Karten wiederholen",
  OPEN_RANDOM_NOTE_DESC: "Wenn dies deaktiviert wird, dann werden die Notizen nach Wichtigkeit wiederholt (PageRank).",
  AUTO_NEXT_NOTE: "Nach einer Wiederholung automatisch die n\xE4chste Karte \xF6ffnen",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Aktiviere die \xDCberpr\xFCfungsoptionen im Dateimen\xFC (z. B. Notizen wiederholen als: Einfach, Gut, Schwer)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Wenn du die \xDCberpr\xFCfungsoptionen im Dateimen\xFC deaktivierst, kannst du deine Notizen mit den Plugin-Befehlen und, falls definiert, den zugeh\xF6rigen Tastenkombinationen \xFCberpr\xFCfen.",
  MAX_N_DAYS_REVIEW_QUEUE: "Maximale Anzahl anstehender Notizen, die im rechten Fensterbereich angezeigt werden",
  MIN_ONE_DAY: "Anzahl der Tage muss mindestens 1 sein.",
  VALID_NUMBER_WARNING: "Bitte eine g\xFCltige Zahl eingeben.",
  UI: "User Interface",
  OPEN_IN_TAB: "\xD6ffne im neuen Tab",
  OPEN_IN_TAB_DESC: "Schalte dies aus, um die Notizen in einem Modalfenster zu \xF6ffnen",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Stapelverzeichnis soll beim \xF6ffnen erweitert angezeigt werden",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Deaktivieren Sie dies, um verschachtelte Stapel in derselben Karte zu reduzieren. N\xFCtzlich, wenn Sie Karten haben, die zu vielen Stapeln in derselben Datei geh\xF6ren.",
  ALGORITHM: "Algorithmus",
  CHECK_ALGORITHM_WIKI: 'Weiterf\xFChrende Informationen: <a href="${algoUrl}">Implementierung des Algorithmus</a> (english).',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Basis der Schwierigkeit",
  BASE_EASE_DESC: "Minimum ist 130. Empfohlen wird ca. 250.",
  BASE_EASE_MIN_WARNING: "Basis der Schwierigkeit muss mindestens 130 sein.",
  LAPSE_INTERVAL_CHANGE: "Anpassungsfaktor des Intervalls wenn eine Notiz / Karte 'Schwer' abgeschlossen wird",
  LAPSE_INTERVAL_CHANGE_DESC: "neuesIntervall = altesIntervall * anpassungsfaktor / 100.",
  EASY_BONUS: "Einfachheit-Bonus",
  EASY_BONUS_DESC: "Der Einfachheit-Bonus gibt an um welchen Faktor (in Prozent) das Intervall l\xE4nger sein soll, wenn eine Notiz / Karte 'Einfach' statt 'Gut' abgeschlossen wird. Minimum ist 100%.",
  EASY_BONUS_MIN_WARNING: "Der Einfachheit-Bonus muss mindestens 100 sein.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maximale Intervall in Tagen",
  MAX_INTERVAL_DESC: "Das maximale Intervall (in Tagen) f\xFCr Wiederholungen. Standard sind 100 Jahre.",
  MAX_INTERVAL_MIN_WARNING: "Das maximale Interall muss mindestens ein Tag sein.",
  MAX_LINK_CONTRIB: "Maximaler Einfluss von Links",
  MAX_LINK_CONTRIB_DESC: "Maximaler Einfluss der Einfachheiten verlinkter Notizen zur gewichteten initialen Einfachheit einer neuen Lernkarte.",
  LOGGING: "Protokollierung",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Informationen zum Debugging in der Entwicklerkonsole anzeigen",
  DISPLAY_PARSER_DEBUG_INFO: "Informationen zum parser Debugging in der Entwicklerkonsole anzeigen",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Anstehende Notizen zur Wiederholung",
  CLOSE: "Schliessen",
  NEW: "Neu",
  YESTERDAY: "Gestern",
  TODAY: "Heute",
  TOMORROW: "Morgen",
  // stats-modal.tsx
  STATS_TITLE: "Statistiken",
  MONTH: "Monat",
  QUARTER: "Quartal",
  YEAR: "Jahr",
  LIFETIME: "Lebenslang",
  FORECAST: "Prognose",
  FORECAST_DESC: "Anzahl der k\xFCnftig anstehenden Karten",
  SCHEDULED: "Anstehend",
  DAYS: "Tage",
  NUMBER_OF_CARDS: "Anzahl der Karten",
  REVIEWS_PER_DAY: "Durchschnitt: ${avg} Wiederholungen/Tag",
  INTERVALS: "Intervalle",
  INTERVALS_DESC: "Intervalle bis Wiederholungen anstehen",
  COUNT: "Anzahl",
  INTERVALS_SUMMARY: "Durchschnittliches Intervall: ${avg}, L\xE4ngstes Intervall: ${longest}",
  EASES: "Schwierigkeit",
  EASES_SUMMARY: "Durchschnittliche Schwierigkeit: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Kategorisierung",
  CARD_TYPES_DESC: "Verlegte Karten eingeschlossen",
  CARD_TYPE_NEW: "Neu",
  CARD_TYPE_YOUNG: "Jung",
  CARD_TYPE_MATURE: "Ausgereift",
  CARD_TYPES_SUMMARY: "Insgesamt ${totalCardsCount} Karten",
  SEARCH: "Suche",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Einstellungen",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Klicke auf die 3 Punkte neben der Notiz, um das Review-Men\xFC zu \xF6ffnen.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Stapel zum Wiederholung \xF6ffnen",
  UPDATE_AVAILABLE: "Update verf\xFCgbar",
  // Statistics
  PERIOD_TITLE: "Zeitraum",
  PERIOD_DESC: "Zeitraum, in dem die Diagramme angezeigt werden",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var de_default = de;

// src/lang/locale/en-gb.ts
var enGB = {
  ...en_default,
  language: "en-gb",
  languageName: "British English"
};
var en_gb_default = enGB;

// src/lang/locale/es.ts
var es = {
  ...en_default,
  language: "es",
  languageName: "Espa\xF1ol",
  // flashcard-modal.tsx
  DECKS: "Mazos",
  DUE_CARDS: "Tarjetas Vencidas",
  NEW_CARDS: "Tarjetas Nuevas",
  TOTAL_CARDS: "Tarjetas Totales",
  BACK: "Atr\xE1s",
  SKIP: "Saltar",
  EDIT_CARD: "Editar Tarjeta",
  RESET_CARD_PROGRESS: "Reiniciar progreso de la tarjeta",
  HARD: "Dif\xEDcil",
  GOOD: "Bien",
  EASY: "F\xE1cil",
  SHOW_ANSWER: "Mostrar Respuesta",
  CARD_PROGRESS_RESET: "El progreso de la tarjeta se ha reiniciado.",
  SAVE: "Guardar",
  CANCEL: "Cancelar",
  NO_INPUT: "Se ha prove\xEDdo entrada.",
  CURRENT_EASE_HELP_TEXT: "Facilidad Actual: ",
  CURRENT_INTERVAL_HELP_TEXT: "Intervalo Actual: ",
  CARD_GENERATED_FROM: "Generado Desde: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Abrir nota para revisi\xF3n",
  REVIEW_CARDS: "Revisar Tarjetas",
  REVIEW_DIFFICULTY_FILE_MENU: "Revisar: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Revisar nota como ${difficulty}",
  CRAM_ALL_CARDS: "Selecciona un mazo a memorizar",
  REVIEW_ALL_CARDS: "Revisar tarjetas de todas las notas",
  REVIEW_CARDS_IN_NOTE: "Revisar tarjetas en esta nota",
  CRAM_CARDS_IN_NOTE: "Memorizar tarjetas en esta nota",
  VIEW_STATS: "Ver estad\xEDsticas",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "Revisar: ${dueNotesCount} nota(s), ${dueFlashcardsCount} tarjetas vencidas",
  SYNC_TIME_TAKEN: "La sincronizaci\xF3n tom\xF3 ${t} milisegundos",
  NOTE_IN_IGNORED_FOLDER: "La nota est\xE1 guardada en un directorio ignorado (revisa los ajustes).",
  PLEASE_TAG_NOTE: "Por favor etiquete apropiadamente la nota para revisi\xF3n (en los ajustes).",
  RESPONSE_RECEIVED: "Respuesta Recibida",
  NO_DECK_EXISTS: "No existen mazos para: ${deckName}",
  ALL_CAUGHT_UP: "\xA1Est\xE1s al d\xEDa! \u{1F603}",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} d\xEDa(s)",
  MONTHS_STR_IVL: "${interval} mes(es)",
  YEARS_STR_IVL: "${interval} a\xF1o(s)",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}a",
  // settings.ts
  SETTINGS_HEADER: "Extensi\xF3n de Repetici\xF3n Espaciada",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: 'Para m\xE1s informaci\xF3n revisa la <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Directorios a ignorar",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Tarjetas de Memorizaci\xF3n",
  FLASHCARD_EASY_LABEL: "Texto del bot\xF3n: F\xE1cil",
  FLASHCARD_GOOD_LABEL: "Texto del bot\xF3n: Bien",
  FLASHCARD_HARD_LABEL: "Texto del bot\xF3n: Dif\xEDcil",
  FLASHCARD_EASY_DESC: "Personalize la etiqueta para el bot\xF3n: F\xE1cil",
  FLASHCARD_GOOD_DESC: "Personalize la etiqueta para el bot\xF3n: Bien",
  FLASHCARD_HARD_DESC: "Personalize la etiqueta para el bot\xF3n: Dif\xEDcil",
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Etiquetas de las Tarjetas de Memorizaci\xF3n",
  FLASHCARD_TAGS_DESC: "Escriba las etiquetas separadas por espacios o saltos de l\xEDnea, por ejemplo, #memorizar #mazo2 #mazo3",
  CONVERT_FOLDERS_TO_DECKS: "\xBFConvertir directorios a mazos y submazos?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Esta es una opci\xF3n alternativa a las etiquetas de las Tarjetas de Memorizaci\xF3n.",
  INLINE_SCHEDULING_COMMENTS: "\xBFGuardar el comentario para programaci\xF3n de las tarjetas en la \xFAltima l\xEDnea?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Activar esto har\xE1 que los comentarios HTML no rompan el formato de las listas.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\xBFEnterrar tarjetas hermanas hasta el siguiente d\xEDa?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Los hermanos son tarjetas generadas del mismo texto de la tarjeta, por ejemplo, deletreos de huecos (cloze deletions en ingl\xE9s)",
  SHOW_CARD_CONTEXT: "\xBFMostrar contexto en las tarjetas?",
  SHOW_CARD_CONTEXT_DESC: "Por Ejemplo: T\xEDtulo > Cabecera > Sub-Cabecera > ... > Sub-Cabecera",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "Porcentaje de la altura de las tarjetas de memoria",
  CARD_MODAL_SIZE_PERCENT_DESC: "Deber\xEDa ser establecido en 100% si tienes im\xE1genes grandes",
  RESET_DEFAULT: "Reiniciar a la configuraci\xF3n por defecto",
  CARD_MODAL_WIDTH_PERCENT: "Porcentaje del ancho de las tarjetas de memoria",
  RANDOMIZE_CARD_ORDER: "\xBFAleatorizar el orden de las tarjetas para revisi\xF3n?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Order cards in a deck are displayed during review",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentially within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentially within a deck (All due cards first)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Randomly within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Randomly within a deck (All due cards first)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_DECK_ORDER: "Order decks are displayed during review",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentially (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Randomly (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  DISABLE_CLOZE_CARDS: "\xBFDeshabilitar deletreo de huecos en las tarjetas?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "\xBFConvertir ==resaltados== a deletreo de huecos?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'A\xF1adir/eliminar el <code>${defaultPattern}</code> de tus "Patrones de Deletreo de Huecos"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "\xBFConvertir **texto en negrita** a deletreo de huecos?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'A\xF1adir/eliminar el <code>${defaultPattern}</code> de tus "Patrones de Deletreo de Huecos"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "\xBFConvertir {{llaves rizadas}} a deletreo de huecos?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'A\xF1adir/eliminar el <code>${defaultPattern}</code> de tus "Patrones de Deletreo de Huecos"',
  CLOZE_PATTERNS: "Patrones de deletreo de huecos",
  CLOZE_PATTERNS_DESC: 'Escriba los patrones de deletreo de huecos separados por saltos de l\xEDnea. . Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Separador de tarjetas de memorizaci\xF3n en l\xEDnea",
  FIX_SEPARATORS_MANUALLY_WARNING: "Note que despu\xE9s de cambiar este ajuste, tendr\xE1 que cambiar manualmente todas las notas que tenga.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Separador de tarjetas de memorizaci\xF3n para tarjetas de notas invertidas",
  MULTILINE_CARDS_SEPARATOR: "Separador para tarjetas de memorizaci\xF3n multil\xEDnea",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Separador para tarjetas de memorizaci\xF3n multil\xEDnea invertidas",
  MULTILINE_CARDS_END_MARKER: "Caracteres que denotan el fin de los clozes y tarjetas did\xE1cticas de varias l\xEDneas",
  NOTES: "Notes",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Activar panel de revisi\xF3n de notas al arrancar",
  TAGS_TO_REVIEW: "Etiquetas a revisar",
  TAGS_TO_REVIEW_DESC: "Escriba las etiquetas separadas por espacios o saltos de l\xEDneas, por ejemplo, #revisi\xF3n #etiqueta2 #etiqueta3.",
  OPEN_RANDOM_NOTE: "Abrir una nota al azar para revisar",
  OPEN_RANDOM_NOTE_DESC: "Cuando deshabilita esto, las notas son ordenadas por importancia (Algoritmo PageRank).",
  AUTO_NEXT_NOTE: "Abrir la siguiente nota autom\xE1ticamente despu\xE9s de una revisi\xF3n",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Habilita las opciones de revisi\xF3n en el men\xFA Archivo (por ejemplo: Revisar: F\xE1cil, Bien, Dif\xEDcil)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Si desactivas las opciones de revisi\xF3n en el men\xFA Archivo, puedes revisar tus notas usando los comandos del plugin y, si los definiste, las teclas r\xE1pidas asociadas.",
  MAX_N_DAYS_REVIEW_QUEUE: "N\xFAmero m\xE1ximo de d\xEDas a mostrar en el panel derecho.",
  MIN_ONE_DAY: "El n\xFAmero de d\xEDas debe ser al menos uno.",
  VALID_NUMBER_WARNING: "Por favor especifique un n\xFAmero v\xE1lido.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Los \xE1rboles de mazos deber\xEDan ser expandidos al inicio.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Desactiva esto para contraer mazos anidados en la misma tarjeta. \xDAtil si tienes tarjetas que pertenecen a muchos mazos en el mismo archivo.",
  ALGORITHM: "Algoritmo",
  CHECK_ALGORITHM_WIKI: 'Para m\xE1s informaci\xF3n, revisa la <a href="${algoUrl}">implementaci\xF3n del algoritmo</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Base ease",
  BASE_EASE_DESC: "El m\xEDnimo es 130, es preferible que est\xE9 aproximado a 250.",
  BASE_EASE_MIN_WARNING: "La facilidad base de las tarjetas debe ser al menos 130.",
  LAPSE_INTERVAL_CHANGE: "El intervalo cambiar\xE1 cuando se revise una tarjeta o nota como Dif\xEDcil.",
  LAPSE_INTERVAL_CHANGE_DESC: "NuevoInterval = ViejoIntervalo * CambioDeIntervalo / 100.",
  EASY_BONUS: "Bonificaci\xF3n para F\xE1cil",
  EASY_BONUS_DESC: "La bonificaci\xF3n para F\xE1cil te permite establecer la diferencia entre intervalos al responder Bien y F\xE1cil en las tarjetas o notas (m\xEDnimo = 100%).",
  EASY_BONUS_MIN_WARNING: "El bono de facilidad debe ser al menos 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Intervalo m\xE1ximo en d\xEDas",
  MAX_INTERVAL_DESC: "Te permite establecer un l\xEDmite mayor en el intervalo (por defecto es de 100 a\xF1os).",
  MAX_INTERVAL_MIN_WARNING: "El intervalo m\xE1ximo debe ser de al menos un d\xEDa.",
  MAX_LINK_CONTRIB: "Contribuci\xF3n m\xE1xima de las notas vinculadas.",
  MAX_LINK_CONTRIB_DESC: "Contribuci\xF3n m\xE1xima de la facilidad ponderada de las notas vinculadas a la facilidad inicial.",
  LOGGING: "Registro",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\xBFMostrar informaci\xF3n de depuraci\xF3n en la consola de desarrollador",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Cola de notas a revisar",
  CLOSE: "Cerrar",
  NEW: "Nuevo",
  YESTERDAY: "Ayer",
  TODAY: "Hoy",
  TOMORROW: "Ma\xF1ana",
  // stats-modal.tsx
  STATS_TITLE: "Estad\xEDsticas",
  MONTH: "Mes",
  QUARTER: "Trimestre o Cuatrimestre",
  // En Inglés: Quarter.
  YEAR: "A\xF1o",
  LIFETIME: "Tiempo de Vida",
  FORECAST: "Pron\xF3stico",
  FORECAST_DESC: "El n\xFAmero de tarjetas vencidas en el futuro",
  SCHEDULED: "Programado",
  DAYS: "D\xEDas",
  NUMBER_OF_CARDS: "N\xFAmero de tarjetas",
  REVIEWS_PER_DAY: "Carga: ${avg} Revisiones por d\xEDa",
  INTERVALS: "Intervalos",
  INTERVALS_DESC: "Retrasos hasta que las revisiones se muestren de nuevo",
  COUNT: "Conteo",
  INTERVALS_SUMMARY: "Intervalo de carga: ${avg}, Intervalo mayor: ${longest}",
  EASES: "Facilidad",
  EASES_SUMMARY: "Carga de Facilidad: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Tipos de tarjetas",
  CARD_TYPES_DESC: "Esto incluye tambi\xE9n a las tarjetas enterradas, si las hay",
  CARD_TYPE_NEW: "Nueva",
  CARD_TYPE_YOUNG: "Joven",
  CARD_TYPE_MATURE: "Madura",
  CARD_TYPES_SUMMARY: "Tarjetas Totales: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var es_default = es;

// src/lang/locale/fr.ts
var fr = {
  ...en_default,
  language: "fr",
  languageName: "Fran\xE7ais",
  // flashcard-modal.tsx
  DECKS: "Paquets",
  DUE_CARDS: "Cartes dues",
  NEW_CARDS: "Nouvelles cartes",
  TOTAL_CARDS: "Total de cartes",
  BACK: "Pr\xE9c\xE9dent",
  SKIP: "Sauter",
  EDIT_CARD: "Modifier la carte",
  RESET_CARD_PROGRESS: "Remettre \xE0 z\xE9ro le niveau de cette carte",
  HARD: "Difficile",
  GOOD: "Correct",
  EASY: "Facile",
  SHOW_ANSWER: "Montrer la r\xE9ponse",
  CARD_PROGRESS_RESET: "Le niveau de la carte a \xE9t\xE9 remis \xE0 z\xE9ro.",
  SAVE: "Sauvegarder",
  CANCEL: "Annuler",
  NO_INPUT: "Pas de contenu.",
  CURRENT_EASE_HELP_TEXT: "Facilit\xE9 actuelle : ",
  CURRENT_INTERVAL_HELP_TEXT: "Intervalle actuel : ",
  CARD_GENERATED_FROM: "G\xE9n\xE9r\xE9 depuis : ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Ouvrir une note \xE0 apprendre",
  REVIEW_CARDS: "Apprendre les flashcards",
  REVIEW_DIFFICULTY_FILE_MENU: "Apprentissage : ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Difficult\xE9 de la r\xE9vision : ${difficulty}",
  CRAM_ALL_CARDS: "Choisir un deck \xE0 r\xE9viser",
  REVIEW_ALL_CARDS: "Apprendre les flashcards dans toutes les notes",
  REVIEW_CARDS_IN_NOTE: "Apprendre les flashcards dans cette note",
  CRAM_CARDS_IN_NOTE: "R\xE9viser les flashcards dans cette note",
  VIEW_STATS: "Voir les statistiques",
  OPEN_REVIEW_QUEUE_VIEW: "Ouvrir la file d'attente des notes \xE0 apprendre dans la barre verticale",
  STATUS_BAR: "Apprentissage : ${dueNotesCount} note(s), ${dueFlashcardsCount} carte(s) dues",
  SYNC_TIME_TAKEN: "Synchronis\xE9 en ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "La note est dans un dossier ignor\xE9 (voir param\xE8tres).",
  PLEASE_TAG_NOTE: "Ajoutez le bon tag \xE0 la note pour l'apprendre (dans les param\xE8tres).",
  RESPONSE_RECEIVED: "R\xE9ponse enregistr\xE9e.",
  NO_DECK_EXISTS: "Pas de paquet sous le nom ${deckName}",
  ALL_CAUGHT_UP: "Bravo, vous \xEAtes \xE0 jour !",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} jour(s)",
  MONTHS_STR_IVL: "${interval} mois(s)",
  YEARS_STR_IVL: "${interval} an(s)",
  DAYS_STR_IVL_MOBILE: "${interval}j",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}a",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Dossiers",
  GROUP_FLASHCARD_REVIEW: "Apprentissage des flashcards",
  GROUP_FLASHCARD_SEPARATORS: "S\xE9parateurs de flashcards",
  GROUP_DATA_STORAGE: "Stockage des informations de planification",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contribuer",
  CHECK_WIKI: 'Pour plus d\'informations, visitez le <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visitez les <a href="${discussionsUrl}">discussions</a> pour des questions-r\xE9ponses, des retours ou une discussion g\xE9n\xE9raliste.',
  GITHUB_ISSUES: 'Cr\xE9ez un ticket <a href="${issuesUrl}">sur GitHub</a> si vous trouvez un bug ou voulez demander une fonctionnalit\xE9.',
  GITHUB_SOURCE_CODE: 'Code source du projet disponible sur <a href="${githubProjectUrl}">GitHub</a>',
  CODE_CONTRIBUTION_INFO: 'Information sur les <a href="${codeContributionUrl}">contributions au code</a>',
  TRANSLATION_CONTRIBUTION_INFO: 'Informations sur la <a href="${translationContributionUrl}">traduction du plugin</a> dans votre langue',
  FOLDERS_TO_IGNORE: "Dossiers \xE0 ignorer",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Flashcards",
  FLASHCARD_EASY_LABEL: "Bouton Facile",
  FLASHCARD_GOOD_LABEL: "Bouton Correct",
  FLASHCARD_HARD_LABEL: "Bouton Difficile",
  FLASHCARD_EASY_DESC: "Changez le texte du bouton Facile",
  FLASHCARD_GOOD_DESC: "Changez le texte du bouton Correct",
  FLASHCARD_HARD_DESC: "Changez le texte du bouton Difficile",
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Tags des flashcards",
  FLASHCARD_TAGS_DESC: "Entrez les tags s\xE9par\xE9s par un espace ou une ligne i.e. #flashcards #paquet2 #paquet3.",
  CONVERT_FOLDERS_TO_DECKS: "Convertir les dossiers en paquets et sous-paquets ?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Ceci est une alternative aux tags de flashcards pr\xE9sent\xE9s ci-dessus.",
  INLINE_SCHEDULING_COMMENTS: "Sauvegarder le commentaire de planification dans la derni\xE8re ligne de la flashcard ?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Activer ceci emp\xEAche les commentaires HTML de casser la mise en page des listes.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Enterrer les cartes s\u0153urs jusqu'au lendemain ?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Les cartes s\u0153urs sont les cartes g\xE9n\xE9r\xE9es depuis le m\xEAme texte, par exemple pour les textes \xE0 trous",
  SHOW_CARD_CONTEXT: "Montrer le contexte dans les cartes ?",
  SHOW_CARD_CONTEXT_DESC: "ex. Titre de la note > Titre 1 > Sous-titre > ... > Sous-titre",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "Pourcentage de hauteur de la flashcard",
  CARD_MODAL_SIZE_PERCENT_DESC: "Devrait \xEAtre 100% sur mobile ou en cas de grandes images",
  RESET_DEFAULT: "R\xE9initialiser les param\xE8tres",
  CARD_MODAL_WIDTH_PERCENT: "Pourcentage de largeur de la flashcard",
  RANDOMIZE_CARD_ORDER: "Apprendre les cartes dans un ordre al\xE9atoire ?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Ordre d'affichage des cartes d'un paquet pendant les r\xE9visions",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Dans l'ordre du paquet (Nouvelles cartes d'abord)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Dans l'ordre du paquet (Cartes dues d'abord)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Al\xE9atoirement dans le paquet (Nouvelles cartes d'abord)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Al\xE9atoirement dans le paquet (Cartes dues d'abord)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Carte au hasard dans un paquet au hasard",
  REVIEW_DECK_ORDER: "Ordre d'affichage des paquets pendant les r\xE9visions",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "S\xE9quentiel (quand toutes les cartes du paquet pr\xE9c\xE9dent sont apprises)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Al\xE9atoire (quand toutes les cartes du paquet pr\xE9c\xE9dent sont apprises)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Carte au hasard dans un paquet au hasard",
  DISABLE_CLOZE_CARDS: "D\xE9sactiver les textes \xE0 trous ?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "Convertir ==soulignages== en trous ?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'Ajouter/supprimer le <code>${defaultPattern}</code> de vos "Cloze Patterns"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "Convertir **gras** en trous ?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'Ajouter/supprimer le <code>${defaultPattern}</code> de vos "Cloze Patterns"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "Convertir {{crochets}} en trous ?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'Ajouter/supprimer le <code>${defaultPattern}</code> de vos "Cloze Patterns"',
  CLOZE_PATTERNS: "Cloze Patterns",
  CLOZE_PATTERNS_DESC: 'Enter cloze patterns separated by newlines. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "S\xE9parateur pour flashcards en une ligne",
  FIX_SEPARATORS_MANUALLY_WARNING: "Apr\xE8s avoir chang\xE9 ce r\xE9glage, vous devrez manuellement mettre \xE0 jour toutes vos flashcards.",
  INLINE_REVERSED_CARDS_SEPARATOR: "S\xE9parateur pour flashcards invers\xE9es en une ligne",
  MULTILINE_CARDS_SEPARATOR: "S\xE9parateur pour flashcards en plusieurs lignes",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "S\xE9parateur pour flashcards invers\xE9es en plusieurs lignes",
  MULTILINE_CARDS_END_MARKER: "Caract\xE8res de fin de textes \xE0 trous ou de flashcards en plusieurs lignes",
  NOTES: "Notes",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Montrer le module d'apprentissage des notes au d\xE9marrage",
  TAGS_TO_REVIEW: "Tags \xE0 apprendre",
  TAGS_TO_REVIEW_DESC: "Entrez les tags s\xE9par\xE9s par un espace ou une ligne i.e. #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "Ouvrir une note \xE0 apprendre au hasard",
  OPEN_RANDOM_NOTE_DESC: "Si vous d\xE9sactivez cette option, les notes sont tri\xE9es par importance (PageRank).",
  AUTO_NEXT_NOTE: "Ouvrir la prochaine note automatiquement apr\xE8s un apprentissage",
  MAX_N_DAYS_REVIEW_QUEUE: "Jours maximum affich\xE9s dans la barre de droite",
  MIN_ONE_DAY: "Le nombre de jours doit \xEAtre au moins 1.",
  VALID_NUMBER_WARNING: "Entrez un nombre valide.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Enable the review options in the file menu (e.g. Review: Easy, Good, Hard)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "If you disable the review options in the file menu, you can review your notes using the plugin commands and, if you defined them, the associated command hotkeys.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Les dossiers de paquets devraient initialement tous \xEAtre ouverts",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "D\xE9sactivez pour r\xE9duire les paquets dans la m\xEAme carte. Ce r\xE9glage est utile si vous avez des cartes qui appartiennent \xE0 beaucoup de paquets \xE0 la fois.",
  ALGORITHM: "Algorithme",
  CHECK_ALGORITHM_WIKI: `Pour en savoir plus, lisez l'<a href="\${algoUrl}">impl\xE9mentation de l'algorithme</a>.`,
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Facilit\xE9 de base",
  BASE_EASE_DESC: "minimum = 130, recommand\xE9 = vers 250.",
  BASE_EASE_MIN_WARNING: "La facilit\xE9 de base doit \xEAtre sup\xE9rieure \xE0 130.",
  LAPSE_INTERVAL_CHANGE: "Changement d'intervalle quand vous indiquez qu'une flashcard/note a \xE9t\xE9 difficile",
  LAPSE_INTERVAL_CHANGE_DESC: "nouvelIntervalle = ancienIntervalle * changementIntervalle / 100.",
  EASY_BONUS: "Bonus Facile",
  EASY_BONUS_DESC: "Le bonus Facile vous permet d'augmenter l'intervalle entre une r\xE9ponse Correct et une r\xE9ponse Facile sur une flashcard/note (minimum = 100%).",
  EASY_BONUS_MIN_WARNING: "Le bonus Facile doit \xEAtre au moins 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Intervalle maximum (en jours)",
  MAX_INTERVAL_DESC: "Vous permet de mettre une limite maximale sur l'intervalle (par d\xE9faut, 100 ans).",
  MAX_INTERVAL_MIN_WARNING: "L'intervalle maximum doit \xEAtre au moins 1 jour.",
  MAX_LINK_CONTRIB: "Contribution maximum des liens",
  MAX_LINK_CONTRIB_DESC: "Contribution maximum de la facilit\xE9 pond\xE9r\xE9e des notes li\xE9es \xE0 la facilit\xE9 initiale.",
  LOGGING: "Logging",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Afficher les informations de d\xE9bogage dans la console de d\xE9veloppement",
  DISPLAY_PARSER_DEBUG_INFO: "Afficher les informations de d\xE9bogage pour le parser dans la console de d\xE9veloppement",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Cartes \xE0 apprendre",
  CLOSE: "Fermer",
  NEW: "Nouveau",
  YESTERDAY: "Hier",
  TODAY: "Aujourd'hui",
  TOMORROW: "Demain",
  // stats-modal.tsx
  STATS_TITLE: "Statistiques",
  MONTH: "Mois",
  QUARTER: "Trimestre",
  YEAR: "Ann\xE9e",
  LIFETIME: "Toujours",
  FORECAST: "Pr\xE9visions",
  FORECAST_DESC: "Le nombre de cartes dues dans le futur",
  SCHEDULED: "Planifi\xE9",
  DAYS: "Jours",
  NUMBER_OF_CARDS: "Nombre de cartes",
  REVIEWS_PER_DAY: "Moyenne : ${avg} apprentissages / jour",
  INTERVALS: "Intervalles",
  INTERVALS_DESC: "Dur\xE9e avant de remontrer une carte",
  COUNT: "Total",
  INTERVALS_SUMMARY: "Intervalle moyen : ${avg}. Intervalle maximum: ${longest}",
  EASES: "Facilit\xE9",
  EASES_SUMMARY: "Facilit\xE9 moyenne : ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Types de cartes",
  CARD_TYPES_DESC: "Ceci inclut les cartes enterr\xE9es, s'il y en a",
  CARD_TYPE_NEW: "Nouvelles",
  CARD_TYPE_YOUNG: "En cours d'apprentissage",
  CARD_TYPE_MATURE: "Matures",
  CARD_TYPES_SUMMARY: "Total de cartes : ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var fr_default = fr;

// src/lang/locale/hi.ts
var hi = {
  ...en_default,
  language: "hi",
  languageName: "\u0939\u093F\u0928\u094D\u0926\u0940"
};
var hi_default = hi;

// src/lang/locale/id.ts
var id = {
  ...en_default,
  language: "id",
  languageName: "Bahasa Indonesia"
};
var id_default = id;

// src/lang/locale/it.ts
var it = {
  ...en_default,
  language: "it",
  languageName: "Italiano",
  // flashcard-modal.tsx
  DECKS: "Mazzi",
  DUE_CARDS: "Schede da fare",
  NEW_CARDS: "Schede nuove",
  TOTAL_CARDS: "Schede totali",
  BACK: "Indietro",
  SKIP: "Salta",
  EDIT_CARD: "Modifica scheda",
  RESET_CARD_PROGRESS: "Ripristina i progressi della scheda",
  HARD: "Difficile",
  GOOD: "Buono",
  EASY: "Facile",
  SHOW_ANSWER: "Mostra risposta",
  CARD_PROGRESS_RESET: "I progressi della scheda sono stati ripristinati",
  SAVE: "Salva",
  CANCEL: "Cancella",
  NO_INPUT: "Non \xE8 stato provvisto alcun input",
  CURRENT_EASE_HELP_TEXT: "Difficolt\xE0 attuale: ",
  CURRENT_INTERVAL_HELP_TEXT: "Intervallo attuale: ",
  CARD_GENERATED_FROM: "Generato da: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Apri una nota per rivisita",
  REVIEW_CARDS: "Rivisita schede",
  REVIEW_DIFFICULTY_FILE_MENU: "Rivisita: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Revisita note come ${difficulty}",
  CRAM_ALL_CARDS: "Seleziona un mazzo da memorizzare",
  REVIEW_ALL_CARDS: "Seleziona schede da rivedere",
  REVIEW_CARDS_IN_NOTE: "Rivedi schede in questa nota",
  CRAM_CARDS_IN_NOTE: "Memorizza schede in questa nota",
  VIEW_STATS: "Vedi statistiche",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "Da rivedere: ${dueNotesCount} scheda/e, ${dueFlashcardsCount} schede in ritardo",
  SYNC_TIME_TAKEN: "Sincronizzato in ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "La nota \xE8 salvata in una cartella ignorata (rivedi le impostazioni).",
  PLEASE_TAG_NOTE: "Per favore etichetta la nota appropriatamente per la revisione (nelle impostazioni).",
  RESPONSE_RECEIVED: "Risposta ricevuta.",
  NO_DECK_EXISTS: "Non esistono mazzi per ${deckName}",
  ALL_CAUGHT_UP: "Sei al passo! :D.",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} giorno/i",
  MONTHS_STR_IVL: "${interval} mese/i",
  YEARS_STR_IVL: "${interval} anno/i",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}y",
  // settings.ts
  SETTINGS_HEADER: "Plugin per ripetizione spaziata",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: 'Per maggiori informazioni, rivolgersi alla <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Cartelle da ignorare",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Schede",
  FLASHCARD_EASY_LABEL: "Testo del bottone facile",
  FLASHCARD_GOOD_LABEL: "Testo del bottone buono",
  FLASHCARD_HARD_LABEL: "Testo del bottone difficile",
  FLASHCARD_EASY_DESC: 'Personalizza il testo per il pulsante "Facile"',
  FLASHCARD_GOOD_DESC: 'Personalizza il testo per il pulsante "Buono"',
  FLASHCARD_HARD_DESC: 'Personalizza il testo per il pulsante "Difficile"',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Etichette delle schede",
  FLASHCARD_TAGS_DESC: "Inserire etichette separate da spazi o a capi, per esempio #flashcards #deck2 #deck3.",
  CONVERT_FOLDERS_TO_DECKS: "Trasformare cartelle in mazzi e sotto-mazzi?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Questa \xE8 un'alternativa all'opzione delle etichette delle schede sopra.",
  INLINE_SCHEDULING_COMMENTS: "Salvare il commento per l'orario sulla stessa linea dell'ultimna linea della scheda?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Attivando quest'impostazione far\xF2 s\xEC che i commento HTML non rompino la formattazione delle liste.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Sotterrare schede sorelle fino al giorno dopo?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Le schede sorelle sono schede generate dallo stesso testo della scheda, per esempio i.e. cloze deletions",
  SHOW_CARD_CONTEXT: "Mostrare contesto nelle schede?",
  SHOW_CARD_CONTEXT_DESC: "per esempio, Titolo > Intestazione 1 > Sottotitolo 1 > ... > Sottotitolo",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "Percentuale altezza schede",
  CARD_MODAL_SIZE_PERCENT_DESC: "Dovrebbe essere 100% se sei su telefono o se hai immagini molto grandi",
  RESET_DEFAULT: "Reimposta alle impostazioni iniziali",
  CARD_MODAL_WIDTH_PERCENT: "Percentuale di larghezza delle schede",
  RANDOMIZE_CARD_ORDER: "Rendere casuale l'ordine delle schede durante la revisione?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "L'ordine in cui le schede saranno visualizzate all'interno del mazzo",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequenzialmente dentro il mazzo (prima schede nuove)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequenzialmente dentro il mazzo (prima schede in ritardo)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "A caso dentro il mazzo (prima schede nuove)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "A caso dentro il mazzo (prima schede in ritardo)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Scheda a caso da mazzo a caso",
  REVIEW_DECK_ORDER: "L'ordine in cui i mazzi vengono mostrati durante la revisione",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequenzialmente (quando le schede nel mazzo precedente saranno state riviste)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "A caso (quando le schede nel mazzo precedente saranno state riviste)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Scheda a caso da mazzo a caso",
  DISABLE_CLOZE_CARDS: "Disabilita schede con spazi da riempire?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "Convertire ==testo evidenziato== in spazi da riempire?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'Aggiungi/rimuovi <code>${defaultPattern}</code> dai tuoi "Modelli per spazi da riempire"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "Convertire **testo in grassetto** in spazi da riempire",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'Aggiungi/rimuovi <code>${defaultPattern}</code> dai tuoi "Modelli per spazi da riempire"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "Convertire {{parentesi graffe}} in spazi da riempire?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'Aggiungi/rimuovi <code>${defaultPattern}</code> dai tuoi "Modelli per spazi da riempire"',
  CLOZE_PATTERNS: "Modelli di spazi da riempire",
  CLOZE_PATTERNS_DESC: 'Inserisci i modelli di spazi da riempire separati da a capo. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Separatore per schede sulla stessa riga",
  FIX_SEPARATORS_MANUALLY_WARNING: "Si avvisa che dopo aver cambiato questo dovrai manualmente modificare le schede che hai gi\xE0.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Separatore per schede all'incontrario sulla stessa riga",
  MULTILINE_CARDS_SEPARATOR: "Separatore per schede su pi\xF9 righe",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Separatore per schede all'incontrario su pi\xF9 righe",
  MULTILINE_CARDS_END_MARKER: "Caratteri che denotano la fine di carte con spazi da riempiere e carte multilinea",
  NOTES: "Note",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Abilita il pannello di revisione note all'avvio",
  TAGS_TO_REVIEW: "Etichette da rivedere",
  TAGS_TO_REVIEW_DESC: "Inserisci le etichette separate da spazi o a capi, tipo #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "Apri una nota a caso per revisione",
  OPEN_RANDOM_NOTE_DESC: "Quando lo disabiliti, le note saranno ordinate per importanza (PageRank).",
  AUTO_NEXT_NOTE: "Apri la prossima nota automaticamente dopo la revisione",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Abilita le opzioni di revisione nel menu File (es.: Rivisita: Facile, Buono, Difficile)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Se disabiliti le opzioni di revisione nel menu File, puoi rivedere le tue note utilizzando i comandi del plugin e, se li hai definiti, le scorciatoie da tastiera associate.",
  MAX_N_DAYS_REVIEW_QUEUE: "Numero di giorni massimi da visualizzare nel pannello di destra",
  MIN_ONE_DAY: "Il numero di giorni deve essere almeno 1.",
  VALID_NUMBER_WARNING: "Per favore, mettere un numero valido.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Alberti di mazzi dovrebbero essere inizialmente visualizzate come espansi",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Disabilitami per collassare mazzi annidati nella stessa scheda. Utile se hai schede che appartengono a pi\xF9 mazzi nello stesso file.",
  ALGORITHM: "Algoritmo",
  CHECK_ALGORITHM_WIKI: "Per maggiori informazioni, visita <a href='${algoUrl}'>l'implementazione dell'algoritmo</a>.",
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Difficolt\xE0 base",
  BASE_EASE_DESC: "mino = 130, preferibilmente circa 250.",
  BASE_EASE_MIN_WARNING: "La difficolt\xE0 base deve essere di almeno 130.",
  LAPSE_INTERVAL_CHANGE: "L'intervallo cambier\xE0 segnando una scheda / nota come difficile",
  LAPSE_INTERVAL_CHANGE_DESC: "Intervallo nuovo = intervallo vecchio * cambio intervallo / 100.",
  EASY_BONUS: "Bonus facilit\xE0",
  EASY_BONUS_DESC: "Il bonus facilit\xE0 ti permette di impostare le differenze negli intervalli tra il rispondere Buono e Facile su una scheda o nota (minimo 100%).",
  EASY_BONUS_MIN_WARNING: "Il bonus facilit\xE0 deve essere di almeno 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Intervallo massimo in giorni",
  MAX_INTERVAL_DESC: "Ti permette di mettere un limite massimo all'intervallo (default 100 anni).",
  MAX_INTERVAL_MIN_WARNING: "L'intervallo massimo deve essere di almeno 1 giorno.",
  MAX_LINK_CONTRIB: "Contributo massimo delle note collegate",
  MAX_LINK_CONTRIB_DESC: "Contributo massimo della difficolt\xE0 pasata delle note collegate alla difficolt\xE0 iniziale.",
  LOGGING: "Registrando",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Visualizza informazione di debug sulla console per sviluppatori",
  DISPLAY_PARSER_DEBUG_INFO: "Visualizza informazione di debug riguardanti il parser sulla console per sviluppatori",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Coda di note da rivedere",
  CLOSE: "Chiusi",
  NEW: "Nuovo/a",
  YESTERDAY: "Ieri",
  TODAY: "Oggi",
  TOMORROW: "Domani",
  // stats-modal.tsx
  STATS_TITLE: "Statistiche",
  MONTH: "Mese",
  QUARTER: "Trimestre",
  YEAR: "Anno",
  LIFETIME: "Per tutta la vita",
  FORECAST: "Previsione",
  FORECAST_DESC: "Il numero di schede che saranno in ritardo in futuro",
  SCHEDULED: "Programmate",
  DAYS: "Giorni",
  NUMBER_OF_CARDS: "Numero di schede",
  REVIEWS_PER_DAY: "Media: ${avg} revisioni/giorno",
  INTERVALS: "Intervalli",
  INTERVALS_DESC: "Ritardi finch\xE9 le revisioni saranno visualizzate di nuovo",
  COUNT: "Conta",
  INTERVALS_SUMMARY: "Intervallo medio: ${avg}, Intervallo massimo: ${longest}",
  EASES: "Difficolt\xE0",
  EASES_SUMMARY: "Difficolt\xE0 media: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Tipi di schede",
  CARD_TYPES_DESC: "Include eventuali schede sepolte",
  CARD_TYPE_NEW: "Nuove",
  CARD_TYPE_YOUNG: "Giovani",
  CARD_TYPE_MATURE: "Mature",
  CARD_TYPES_SUMMARY: "Schede tottali: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var it_default = it;

// src/lang/locale/ja.ts
var ja = {
  ...en_default,
  language: "ja",
  languageName: "\u65E5\u672C\u8A9E",
  // flashcard-modal.tsx
  DECKS: "\u30C7\u30C3\u30AD",
  DUE_CARDS: "\u671F\u65E5\u306E\u30AB\u30FC\u30C9",
  NEW_CARDS: "\u65B0\u898F\u306E\u30AB\u30FC\u30C9",
  TOTAL_CARDS: "\u30AB\u30FC\u30C9\u5408\u8A08",
  BACK: "Back",
  SKIP: "Skip",
  EDIT_CARD: "Edit Card",
  RESET_CARD_PROGRESS: "\u30AB\u30FC\u30C9\u306E\u9032\u6357\u3092\u30EA\u30BB\u30C3\u30C8",
  HARD: "Hard",
  GOOD: "Good",
  EASY: "Easy",
  SHOW_ANSWER: "\u89E3\u7B54\u3092\u8868\u793A",
  CARD_PROGRESS_RESET: "\u30AB\u30FC\u30C9\u306E\u9032\u6357\u304C\u30EA\u30BB\u30C3\u30C8\u3055\u308C\u307E\u3057\u305F\u3002",
  SAVE: "Save",
  CANCEL: "Cancel",
  NO_INPUT: "No input provided.",
  CURRENT_EASE_HELP_TEXT: "Current Ease: ",
  CURRENT_INTERVAL_HELP_TEXT: "Current Interval: ",
  CARD_GENERATED_FROM: "Generated from: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\u30EC\u30D3\u30E5\u30FC\u3059\u308B\u30CE\u30FC\u30C8\u3092\u958B\u304F",
  REVIEW_CARDS: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306E\u30EC\u30D3\u30E5\u30FC",
  REVIEW_DIFFICULTY_FILE_MENU: "\u30EC\u30D3\u30E5\u30FC: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "\u30CE\u30FC\u30C8\u3092${difficulty}\u3068\u3057\u3066\u30EC\u30D3\u30E5\u30FC\u3059\u308B",
  REVIEW_ALL_CARDS: "\u3059\u3079\u3066\u306E\u30CE\u30FC\u30C8\u304B\u3089\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u3092\u30EC\u30D3\u30E5\u30FC\u3059\u308B",
  CRAM_ALL_CARDS: "Select a deck to cram",
  REVIEW_CARDS_IN_NOTE: "\u3053\u306E\u30CE\u30FC\u30C8\u306E\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u3092\u30EC\u30D3\u30E5\u30FC\u3059\u308B",
  CRAM_CARDS_IN_NOTE: "\u3053\u306E\u30CE\u30FC\u30C8\u306E\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u3092\u8A70\u3081\u8FBC\u307F\u5B66\u7FD2\u3059\u308B",
  VIEW_STATS: "\u7D71\u8A08\u3092\u95B2\u89A7\u3059\u308B",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "\u30EC\u30D3\u30E5\u30FC: ${dueNotesCount}\u30CE\u30FC\u30C8, ${dueFlashcardsCount}\u30AB\u30FC\u30C9\u304C\u671F\u65E5",
  SYNC_TIME_TAKEN: "\u540C\u671F\u306B${t}ms\u304B\u304B\u308A\u307E\u3057\u305F\u3002",
  NOTE_IN_IGNORED_FOLDER: "\u30CE\u30FC\u30C8\u304C\u7121\u8996\u3059\u308B\u30D5\u30A9\u30EB\u30C0\u306B\u4FDD\u5B58\u3055\u308C\u3066\u3044\u307E\u3059(\u8A2D\u5B9A\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044)\u3002",
  PLEASE_TAG_NOTE: "\u30EC\u30D3\u30E5\u30FC\u3092\u884C\u3046\u306B\u306F\u30CE\u30FC\u30C8\u306B\u5BFE\u3057\u3066\u6B63\u3057\u304F\u30BF\u30B0\u4ED8\u3051\u3057\u3066\u304F\u3060\u3055\u3044(\u8A2D\u5B9A\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044)\u3002",
  RESPONSE_RECEIVED: "\u7B54\u3048\u3092\u53D7\u3051\u53D6\u308A\u307E\u3057\u305F\u3002",
  NO_DECK_EXISTS: "${deckName}\u306B\u306F\u30C7\u30C3\u30AD\u304C\u5B58\u5728\u3057\u307E\u305B\u3093\u3002",
  ALL_CAUGHT_UP: "\u4ECA\u65E5\u306E\u8AB2\u984C\u3092\u3059\u3079\u3066\u9054\u6210\u3057\u307E\u3057\u305F :D",
  // scheduling.ts
  DAYS_STR_IVL: "${interval}\u65E5\u5F8C",
  MONTHS_STR_IVL: "${interval}\u6708\u5F8C",
  YEARS_STR_IVL: "${interval}\u5E74\u5F8C",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}y",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: '\u8A73\u7D30\u306B\u3064\u3044\u3066\u306F<a href="${wikiUrl}">wiki</a>\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "\u7121\u8996\u3059\u308B\u30D5\u30A9\u30EB\u30C0",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9",
  FLASHCARD_EASY_LABEL: "Easy Button Text",
  FLASHCARD_GOOD_LABEL: "Good Button Text",
  FLASHCARD_HARD_LABEL: "Hard Button Text",
  FLASHCARD_EASY_DESC: 'Customize the label for the "Easy" Button',
  FLASHCARD_GOOD_DESC: 'Customize the label for the "Good" Button',
  FLASHCARD_HARD_DESC: 'Customize the label for the "Hard" Button',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306B\u4F7F\u7528\u3059\u308B\u30BF\u30B0",
  FLASHCARD_TAGS_DESC: '\u30BF\u30B0\u3092\u30B9\u30DA\u30FC\u30B9\u307E\u305F\u306F\u6539\u884C\u3067\u533A\u5207\u3063\u3066\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B: "#flashcards #deck2 #deck3"',
  CONVERT_FOLDERS_TO_DECKS: "\u30D5\u30A9\u30EB\u30C0\u3092\u30C7\u30C3\u30AD\u3068\u30B5\u30D6\u30C7\u30C3\u30AD\u3068\u3057\u3066\u4F7F\u7528\u3057\u307E\u3059\u304B\uFF1F",
  CONVERT_FOLDERS_TO_DECKS_DESC: "\u3053\u308C\u306F\u4E0A\u8A18\u306E\u30BF\u30B0\u3092\u4F7F\u7528\u3057\u305F\u30C7\u30C3\u30AD\u69CB\u7BC9\u306E\u4EE3\u66FF\u3068\u306A\u308B\u30AA\u30D7\u30B7\u30E7\u30F3\u3067\u3059\u3002",
  INLINE_SCHEDULING_COMMENTS: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306E\u6700\u7D42\u884C\u3068\u540C\u4E00\u306E\u884C\u306B\u30B9\u30B1\u30B8\u30E5\u30FC\u30EA\u30F3\u30B0\u30B3\u30E1\u30F3\u30C8\u3092\u4FDD\u5B58\u3057\u307E\u3059\u304B\uFF1F",
  INLINE_SCHEDULING_COMMENTS_DESC: "\u3053\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6709\u52B9\u5316\u3059\u308B\u3068\u3001HTML\u30B3\u30E1\u30F3\u30C8\u306B\u3088\u3063\u3066Markdown\u306E\u30EA\u30B9\u30C8\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u304C\u5D29\u308C\u306A\u304F\u306A\u308A\u307E\u3059\u3002",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\u6B21\u306E\u30EC\u30D3\u30E5\u30FC\u307E\u3067\u30B7\u30D6\u30EA\u30F3\u30B0\u3092\u5EF6\u671F\u3057\u307E\u3059\u304B\uFF1F",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "\u30B7\u30D6\u30EA\u30F3\u30B0\u306F\u540C\u4E00\u306E\u30AB\u30FC\u30C9\u30C6\u30AD\u30B9\u30C8\u304B\u3089\u751F\u6210\u3055\u308C\u305F\u30AB\u30FC\u30C9\u3001\u3064\u307E\u308A\u7A74\u57CB\u3081\u554F\u984C\u306E\u6D3E\u751F\u30AB\u30FC\u30C9\u3067\u3059\u3002",
  SHOW_CARD_CONTEXT: "\u30AB\u30FC\u30C9\u306B\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3092\u8868\u793A\u3057\u307E\u3059\u304B\uFF1F",
  SHOW_CARD_CONTEXT_DESC: "\uFF62\u30BF\u30A4\u30C8\u30EB > \u898B\u51FA\u3057 1 > \u526F\u898B\u51FA\u3057 > ... > \u526F\u898B\u51FA\u3057\uFF63\u306E\u8868\u793A\u3092\u884C\u3046\u304B\u3069\u3046\u304B\u3092\u6C7A\u3081\u307E\u3059\u3002",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306E\u7E26\u30B5\u30A4\u30BA\u306E\u30D1\u30FC\u30BB\u30F3\u30C6\u30FC\u30B8",
  CARD_MODAL_SIZE_PERCENT_DESC: "\u30E2\u30D0\u30A4\u30EB\u7248\u3001\u307E\u305F\u306F\u975E\u5E38\u306B\u5927\u304D\u306A\u30B5\u30A4\u30BA\u306E\u753B\u50CF\u304C\u3042\u308B\u5834\u5408\u306B\u306F100%\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002",
  RESET_DEFAULT: "\u30C7\u30D5\u30A9\u30EB\u30C8\u5024\u306B\u30EA\u30BB\u30C3\u30C8\u3059\u308B",
  CARD_MODAL_WIDTH_PERCENT: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306E\u6A2A\u30B5\u30A4\u30BA\u306E\u30D1\u30FC\u30BB\u30F3\u30C6\u30FC\u30B8",
  RANDOMIZE_CARD_ORDER: "\u30EC\u30D3\u30E5\u30FC\u4E2D\u306E\u30AB\u30FC\u30C9\u306E\u9806\u756A\u3092\u30E9\u30F3\u30C0\u30E0\u306B\u3057\u307E\u3059\u304B\uFF1F",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Order cards in a deck are displayed during review",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentially within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentially within a deck (All due cards first)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Randomly within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Randomly within a deck (All due cards first)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_DECK_ORDER: "Order decks are displayed during review",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentially (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Randomly (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  DISABLE_CLOZE_CARDS: "\u7A74\u57CB\u3081\u30AB\u30FC\u30C9\u3092\u7121\u52B9\u5316\u3057\u307E\u3059\u304B\uFF1F",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "==\u30CF\u30A4\u30E9\u30A4\u30C8==\u3092\u7A74\u57CB\u3081\u3068\u3057\u3066\u4F7F\u7528\u3057\u307E\u3059\u304B\uFF1F",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: "\u3053\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6709\u52B9\u5316\u3059\u308B\u3068\u3001\u300C\u7A74\u57CB\u3081\u30D1\u30BF\u30FC\u30F3\u300D\u306B${defaultPattern}\u304C\u8FFD\u52A0\u3055\u308C\u307E\u3059\u3002",
  CONVERT_BOLD_TEXT_TO_CLOZES: "**\u30DC\u30FC\u30EB\u30C9\u4F53**\u3092\u7A74\u57CB\u3081\u3068\u3057\u3066\u4F7F\u7528\u3057\u307E\u3059\u304B\uFF1F",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: "\u3053\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6709\u52B9\u5316\u3059\u308B\u3068\u3001\u300C\u7A74\u57CB\u3081\u30D1\u30BF\u30FC\u30F3\u300D\u306B${defaultPattern}\u304C\u8FFD\u52A0\u3055\u308C\u307E\u3059\u3002",
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "{{\u4E2D\u62EC\u5F27}}\u3092\u7A74\u57CB\u3081\u3068\u3057\u3066\u4F7F\u7528\u3057\u307E\u3059\u304B\uFF1F",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: "\u3053\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6709\u52B9\u5316\u3059\u308B\u3068\u3001\u300C\u7A74\u57CB\u3081\u30D1\u30BF\u30FC\u30F3\u300D\u306B${defaultPattern}\u304C\u8FFD\u52A0\u3055\u308C\u307E\u3059\u3002",
  CLOZE_PATTERNS: "\u7A74\u57CB\u3081\u30D1\u30BF\u30FC\u30F3",
  CLOZE_PATTERNS_DESC: '\u6539\u884C\u3067\u533A\u5207\u3063\u3066\u7A74\u57CB\u3081\u30D1\u30BF\u30FC\u30F3\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002 Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "\u30A4\u30F3\u30E9\u30A4\u30F3\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306B\u4F7F\u7528\u3059\u308B\u30BB\u30D1\u30EC\u30FC\u30BF\u30FC",
  FIX_SEPARATORS_MANUALLY_WARNING: "\u3053\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u5909\u66F4\u3059\u308B\u5834\u5408\u306B\u306F\u3001\u4F5C\u6210\u6E08\u307F\u306E\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u3092\u624B\u52D5\u3067\u7DE8\u96C6\u3057\u76F4\u3059\u5FC5\u8981\u304C\u3042\u308B\u3053\u3068\u306B\u6CE8\u610F\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  INLINE_REVERSED_CARDS_SEPARATOR: "\u30A4\u30F3\u30E9\u30A4\u30F3\u306E\u8868\u88CF\u53CD\u8EE2\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306B\u4F7F\u7528\u3059\u308B\u30BB\u30D1\u30EC\u30FC\u30BF\u30FC",
  MULTILINE_CARDS_SEPARATOR: "\u8907\u6570\u884C\u306E\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306B\u4F7F\u7528\u3059\u308B\u30BB\u30D1\u30EC\u30FC\u30BF\u30FC",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\u8907\u6570\u884C\u306E\u8868\u88CF\u53CD\u8EE2\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306B\u4F7F\u7528\u3059\u308B\u30BB\u30D1\u30EC\u30FC\u30BF\u30FC",
  MULTILINE_CARDS_END_MARKER: "\u30AF\u30ED\u30FC\u30BA\u3068\u8907\u6570\u884C\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9\u306E\u7D42\u308F\u308A\u3092\u793A\u3059\u6587\u5B57",
  NOTES: "\u30CE\u30FC\u30C8",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Enable note review pane on startup",
  TAGS_TO_REVIEW: "\u30EC\u30D3\u30E5\u30FC\u306B\u4F7F\u7528\u3059\u308B\u30BF\u30B0",
  TAGS_TO_REVIEW_DESC: '\u30BF\u30B0\u3092\u30B9\u30DA\u30FC\u30B9\u307E\u305F\u306F\u6539\u884C\u3067\u533A\u5207\u3063\u3066\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B: "#review #tag2 #tag3"',
  OPEN_RANDOM_NOTE: "\u30E9\u30F3\u30C0\u30E0\u306B\u30CE\u30FC\u30C8\u3092\u958B\u3044\u3066\u30EC\u30D3\u30E5\u30FC\u3059\u308B",
  OPEN_RANDOM_NOTE_DESC: "\u3053\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u304C\u7121\u52B9\u5316\u3055\u308C\u3066\u3044\u308B\u72B6\u614B\u3067\u306F\u3001\u30CE\u30FC\u30C8\u306F\u91CD\u8981\u5EA6(\u30DA\u30FC\u30B8\u30E9\u30F3\u30AF)\u306B\u3088\u308B\u9806\u756A\u3067\u8868\u793A\u3055\u308C\u307E\u3059\u3002",
  AUTO_NEXT_NOTE: "\u30EC\u30D3\u30E5\u30FC\u5F8C\u306B\u6B21\u306E\u30CE\u30FC\u30C8\u3092\u81EA\u52D5\u7684\u306B\u958B\u304F",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\u30D5\u30A1\u30A4\u30EB\u30E1\u30CB\u30E5\u30FC\u3067\u30EC\u30D3\u30E5\u30FC\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6709\u52B9\u306B\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: Easy, Good, Hard\uFF09",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\u30D5\u30A1\u30A4\u30EB\u30E1\u30CB\u30E5\u30FC\u3067\u30EC\u30D3\u30E5\u30FC\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u7121\u52B9\u306B\u3057\u305F\u5834\u5408\u3001\u30D7\u30E9\u30B0\u30A4\u30F3\u30B3\u30DE\u30F3\u30C9\u3084\u3001\u8A2D\u5B9A\u3057\u3066\u3044\u308B\u5834\u5408\u306F\u5BFE\u5FDC\u3059\u308B\u30DB\u30C3\u30C8\u30AD\u30FC\u3092\u4F7F\u7528\u3057\u3066\u30E1\u30E2\u3092\u30EC\u30D3\u30E5\u30FC\u3067\u304D\u307E\u3059\u3002",
  MAX_N_DAYS_REVIEW_QUEUE: "\u53F3\u30D1\u30CD\u30EB\u306B\u8868\u793A\u3059\u308B\u6700\u5927\u306E\u65E5\u6570",
  MIN_ONE_DAY: "\u65E5\u6570\u306B\u306F1\u4EE5\u4E0A\u306E\u6570\u5B57\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  VALID_NUMBER_WARNING: "\u6709\u52B9\u306A\u6570\u5B57\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\u30C7\u30C3\u30AD \u30C4\u30EA\u30FC\u306F\u6700\u521D\u306F\u5C55\u958B\u3057\u3066\u8868\u793A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "\u3053\u308C\u3092\u30AA\u30D5\u306B\u3059\u308B\u3068\u3001\u540C\u3058\u30AB\u30FC\u30C9\u5185\u306E\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30C7\u30C3\u30AD\u304C\u6298\u308A\u305F\u305F\u307E\u308C\u307E\u3059\u3002\u540C\u3058\u30D5\u30A1\u30A4\u30EB\u306B\u591A\u304F\u306E\u30C7\u30C3\u30AD\u306B\u5C5E\u3059\u308B\u30AB\u30FC\u30C9\u304C\u3042\u308B\u5834\u5408\u306B\u4FBF\u5229\u3067\u3059\u3002",
  ALGORITHM: "\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0",
  CHECK_ALGORITHM_WIKI: '\u8A73\u7D30\u306B\u3064\u3044\u3066\u306F<a href="${algoUrl}">\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0\u306E\u5B9F\u88C5</a>\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "\u30D9\u30FC\u30B9\u306E\u6613\u3057\u3055",
  BASE_EASE_DESC: "\u6700\u5C0F\u5024\u306F130\u3067\u3059\u304C\u3001 \u9069\u6B63\u5024\u306F\u304A\u304A\u3088\u305D250\u3067\u3059\u3002",
  BASE_EASE_MIN_WARNING: "\u30D9\u30FC\u30B9\u306E\u6613\u3057\u3055\u306B\u306F130\u4EE5\u4E0A\u306E\u6570\u5B57\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  LAPSE_INTERVAL_CHANGE: "\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9/\u30CE\u30FC\u30C8\u3092Hard\u3068\u3057\u3066\u30EC\u30D3\u30E5\u30FC\u3057\u305F\u969B\u306E\u9593\u9694\u5909\u66F4",
  LAPSE_INTERVAL_CHANGE_DESC: '"\u65B0\u3057\u3044\u9593\u9694 = \u4EE5\u524D\u306E\u9593\u9694 * \u9593\u9694\u5909\u66F4 / 100" \u3068\u3057\u3066\u8A08\u7B97\u3055\u308C\u307E\u3059\u3002',
  EASY_BONUS: "Easy\u30DC\u30FC\u30CA\u30B9",
  EASY_BONUS_DESC: "Easy\u30DC\u30FC\u30CA\u30B9\u306B\u3088\u3063\u3066\u30D5\u30E9\u30C3\u30B7\u30E5\u30AB\u30FC\u30C9/\u30CE\u30FC\u30C8\u306B\u304A\u3051\u308B\u9593\u9694\u306E\u5DEE\u5206\u3092\u8A2D\u5B9A\u3067\u304D\u307E\u3059(\u6700\u5C0F\u5024 = 100%)\u3002",
  EASY_BONUS_MIN_WARNING: "Easy\u30DC\u30FC\u30CA\u30B9\u306B\u306F100\u4EE5\u4E0A\u306E\u6570\u5B57\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maximum interval in days",
  MAX_INTERVAL_DESC: "\u9593\u9694\u306B\u4E0A\u9650\u5024\u3092\u8A2D\u5B9A\u3059\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u3059(\u30C7\u30D5\u30A9\u30EB\u30C8\u5024 = 100\u5E74)\u3002",
  MAX_INTERVAL_MIN_WARNING: "\u9593\u9694\u306E\u6700\u5927\u5024\u306B\u306F1\u4EE5\u4E0A\u306E\u6570\u5B57\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  MAX_LINK_CONTRIB: "\u30EA\u30F3\u30AF\u30B3\u30F3\u30C8\u30EA\u30D3\u30E5\u30FC\u30B7\u30E7\u30F3\u306E\u6700\u5927\u5024",
  MAX_LINK_CONTRIB_DESC: "\u6700\u521D\u306E\u6613\u3057\u3055\u306B\u5BFE\u3057\u3066\u3001\u30EA\u30F3\u30AF\u3055\u308C\u305F\u30CE\u30FC\u30C8\u306E\u91CD\u307F\u4ED8\u3051\u3055\u308C\u305F\u6613\u3057\u3055\u304C\u5BC4\u4E0E\u3059\u308B\u6700\u5927\u5024\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
  LOGGING: "\u30ED\u30B0\u7BA1\u7406",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\u30C7\u30D9\u30ED\u30C3\u30D1\u30FC\u30B3\u30F3\u30BD\u30FC\u30EB\u306B\u3066\u30C7\u30D0\u30C3\u30B0\u60C5\u5831\u3092\u8868\u793A\u3057\u307E\u3059\u304B",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\u30CE\u30FC\u30C8\u30EC\u30D3\u30E5\u30FC\u306E\u30AD\u30E5\u30FC",
  CLOSE: "\u9589\u3058\u308B",
  NEW: "\u65B0\u898F",
  YESTERDAY: "\u6628\u65E5",
  TODAY: "\u4ECA\u65E5",
  TOMORROW: "\u660E\u65E5",
  // stats-modal.tsx
  STATS_TITLE: "\u7D71\u8A08",
  MONTH: "Month",
  QUARTER: "Quarter",
  YEAR: "Year",
  LIFETIME: "Lifetime",
  FORECAST: "\u4E88\u6E2C",
  FORECAST_DESC: "\u5FA9\u7FD2\u671F\u65E5\u304C\u6765\u308B\u30AB\u30FC\u30C9\u306E\u679A\u6570",
  SCHEDULED: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EA\u30F3\u30B0\u6E08\u307F",
  DAYS: "\u65E5",
  NUMBER_OF_CARDS: "\u30AB\u30FC\u30C9\u6570",
  REVIEWS_PER_DAY: "\u5E73\u5747: ${avg}\u30EC\u30D3\u30E5\u30FC/\u65E5",
  INTERVALS: "\u9593\u9694",
  INTERVALS_DESC: "\u6B21\u306E\u30EC\u30D3\u30E5\u30FC\u4E88\u5B9A\u65E5",
  COUNT: "\u30AB\u30A6\u30F3\u30C8",
  INTERVALS_SUMMARY: "\u9593\u9694\u306E\u5E73\u5747\u5024: ${avg}, \u6700\u9577\u306E\u9593\u9694: ${longest}",
  EASES: "\u6613\u3057\u3055",
  EASES_SUMMARY: "\u6613\u3057\u3055\u306E\u5E73\u5747\u5024: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "\u30AB\u30FC\u30C9\u30BF\u30A4\u30D7",
  CARD_TYPES_DESC: "\u5EF6\u671F\u306E\u30AB\u30FC\u30C9\u304C\u3042\u308B\u5834\u5408\u306B\u306F\u3053\u308C\u306B\u542B\u307E\u308C\u307E\u3059",
  CARD_TYPE_NEW: "\u65B0\u898F",
  CARD_TYPE_YOUNG: "\u5FA9\u7FD2(\u521D\u671F)",
  CARD_TYPE_MATURE: "\u5FA9\u7FD2(\u5F8C\u671F)",
  CARD_TYPES_SUMMARY: "\u30AB\u30FC\u30C9\u306E\u5408\u8A08: ${totalCardsCount}\u679A",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var ja_default = ja;

// src/lang/locale/ko.ts
var ko = {
  ...en_default,
  language: "ko",
  languageName: "\uD55C\uAD6D\uC5B4",
  // flashcard-modal.tsx
  DECKS: "\uB371",
  DUE_CARDS: "\uB2E4\uC2DC \uBCFC \uCE74\uB4DC\uB4E4",
  NEW_CARDS: "\uC0C8\uB85C\uC6B4 \uCE74\uB4DC\uB4E4",
  TOTAL_CARDS: "\uC804\uCCB4 \uCE74\uB4DC\uB4E4",
  BACK: "Back",
  SKIP: "Skip",
  EDIT_CARD: "Edit Card",
  RESET_CARD_PROGRESS: "\uCE74\uB4DC\uC758 \uC9C4\uD589\uC0C1\uD669\uC744 \uCD08\uAE30\uD654\uD569\uB2C8\uB2E4.",
  HARD: "\uC5B4\uB824\uC6C0(Hard)",
  GOOD: "\uC88B\uC74C(Good)",
  EASY: "\uC26C\uC6C0(Easy)",
  SHOW_ANSWER: "\uC815\uB2F5 \uD655\uC778\uD558\uAE30",
  CARD_PROGRESS_RESET: "\uCE74\uB4DC\uC758 \uC9C4\uD589\uC0C1\uD669\uC774 \uCD08\uAE30\uD654\uB418\uC5C8\uC2B5\uB2C8\uB2E4.",
  SAVE: "Save",
  CANCEL: "Cancel",
  NO_INPUT: "No input provided.",
  CURRENT_EASE_HELP_TEXT: "Current Ease: ",
  CURRENT_INTERVAL_HELP_TEXT: "Current Interval: ",
  CARD_GENERATED_FROM: "Generated from: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\uB9AC\uBDF0\uD560 \uB178\uD2B8 \uC5F4\uAE30",
  REVIEW_CARDS: "\uD50C\uB798\uC2DC\uCE74\uB4DC \uB9AC\uBDF0",
  REVIEW_DIFFICULTY_FILE_MENU: "\uB9AC\uBDF0: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "\uB178\uD2B8\uB97C ${difficulty}\uC73C\uB85C \uB9AC\uBDF0\uD569\uB2C8\uB2E4",
  REVIEW_ALL_CARDS: "\uBAA8\uB4E0 \uB178\uD2B8\uB4E4\uC758 \uD50C\uB798\uC2DC\uCE74\uB4DC\uB4E4\uC744 \uB9AC\uBDF0\uD569\uB2C8\uB2E4",
  CRAM_ALL_CARDS: "Select a deck to cram",
  REVIEW_CARDS_IN_NOTE: "\uC774 \uB178\uD2B8\uC758 \uD50C\uB798\uC2DC\uCE74\uB4DC\uB4E4\uC744 \uB9AC\uBDF0\uD569\uB2C8\uB2E4",
  CRAM_CARDS_IN_NOTE: "\uC774 \uB178\uD2B8\uC758 \uD50C\uB798\uC2DC\uCE74\uB4DC\uB4E4\uC744 \uBCBC\uB77D\uCE58\uAE30\uD569\uB2C8\uB2E4.",
  VIEW_STATS: "\uD1B5\uACC4 \uD655\uC778",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "--\uB9AC\uBDF0: ${dueNotesCount} \uB178\uD2B8, ${dueFlashcardsCount} \uCE74\uB4DC \uB0A8\uC558\uC2B5\uB2C8\uB2E4.",
  SYNC_TIME_TAKEN: "\uB3D9\uAE30\uD654\uC5D0 ${t}\uBC00\uB9AC\uCD08 \uAC78\uB838\uC2B5\uB2C8\uB2E4",
  NOTE_IN_IGNORED_FOLDER: "\uB178\uD2B8\uAC00 \uBB34\uC2DC\uB41C \uD3F4\uB354 \uC544\uB798\uC5D0 \uC800\uC7A5\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4. (\uC124\uC815\uC744 \uD655\uC778\uD574\uC8FC\uC138\uC694)",
  PLEASE_TAG_NOTE: "\uB9AC\uBDF0\uB97C \uD558\uAE30\uC704\uD574 \uB178\uD2B8\uC5D0 \uC801\uC808\uD788 \uD0DC\uADF8\uD574\uC8FC\uC138\uC694. (\uC124\uC815\uC744 \uD655\uC778\uD574\uC8FC\uC138\uC694)",
  RESPONSE_RECEIVED: "\uC694\uCCAD\uC774 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
  NO_DECK_EXISTS: "${deckName}\uC774\uB77C\uB294 \uC774\uB984\uC758 \uB371\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
  ALL_CAUGHT_UP: "\uBAA8\uB450 \uD655\uC778\uD588\uC2B5\uB2C8\uB2E4. :D",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} \uC77C \uD6C4",
  MONTHS_STR_IVL: "${interval} \uAC1C\uC6D4 \uD6C4",
  YEARS_STR_IVL: "${interval} \uB144 \uD6C4",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}y",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: '\uB354 \uB9CE\uC740 \uC815\uBCF4\uB97C \uC6D0\uD558\uC2DC\uBA74, <a href="${wikiUrl}">wiki</a>\uB97C \uD655\uC778\uD574\uC8FC\uC138\uC694.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "\uBB34\uC2DC\uD560 \uD3F4\uB354\uB4E4",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "\uD50C\uB798\uC2DC\uCE74\uB4DC",
  FLASHCARD_EASY_LABEL: "Easy Button Text",
  FLASHCARD_GOOD_LABEL: "Good Button Text",
  FLASHCARD_HARD_LABEL: "Hard Button Text",
  FLASHCARD_EASY_DESC: 'Customize the label for the "Easy" Button',
  FLASHCARD_GOOD_DESC: 'Customize the label for the "Good" Button',
  FLASHCARD_HARD_DESC: 'Customize the label for the "Hard" Button',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "\uD50C\uB798\uC2DC\uCE74\uB4DC \uD0DC\uADF8",
  FLASHCARD_TAGS_DESC: "\uD0DC\uADF8\uB97C \uACF5\uBC31 \uB610\uB294 \uBE48 \uC904\uB85C \uAD6C\uBD84\uD574\uC11C \uC785\uB825\uD574\uC8FC\uC138\uC694. \uC608) '#flashcards #deck2 #deck3'",
  CONVERT_FOLDERS_TO_DECKS: "\uD3F4\uB354\uB97C \uB371\uACFC \uC11C\uBE0C\uB371\uC73C\uB85C \uC0AC\uC6A9\uD560\uAE4C\uC694?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "\uC774 \uAE30\uB2A5\uC740 \uC704\uC758 \uD50C\uB798\uC2DC\uCE74\uB4DC \uD0DC\uADF8 \uC635\uC158\uC744 \uB300\uCCB4\uD569\uB2C8\uB2E4.",
  INLINE_SCHEDULING_COMMENTS: "\uD50C\uB798\uC2DC\uCE74\uB4DC\uC758 \uB9C8\uC9C0\uB9C9 \uC904\uACFC \uB3D9\uC77C\uD55C \uC904\uC5D0 \uC2A4\uCF00\uC904\uB9C1 \uCF54\uBA58\uD2B8\uB97C \uC800\uC7A5\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  INLINE_SCHEDULING_COMMENTS_DESC: "\uC774 \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uBA74 HTML \uC8FC\uC11D\uC774 \uBAA9\uB85D\uC758 \uD3EC\uB9E4\uD305\uC744 \uBB34\uB108\uD2B8\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Sibling \uCE74\uB4DC\uB97C \uB2E4\uC74C\uB0A0\uAE4C\uC9C0 \uBB3B\uC5B4\uB450\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Sibling \uCE74\uB4DC\uB294 \uB3D9\uC77C\uD55C \uCE74\uB4DC \uD14D\uC2A4\uD2B8\uC5D0\uC11C \uC0DD\uC131\uB41C \uCE74\uB4DC\uC785\uB2C8\uB2E4. i.e. cloze deletions",
  SHOW_CARD_CONTEXT: "\uCE74\uB4DC\uC758 \uBB38\uB9E5(context)\uC744 \uD45C\uC2DC\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  SHOW_CARD_CONTEXT_DESC: "\uCE74\uB4DC\uC5D0\uC11C 'Title > Heading 1 > Subheading > ... > Subheading' \uC758 \uD45C\uC2DC\uB97C \uD560\uC9C0 \uC124\uC815\uD569\uB2C8\uB2E4.",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "\uD50C\uB798\uC2DC\uCE74\uB4DC \uB192\uC774 \uBE44\uC728",
  CARD_MODAL_SIZE_PERCENT_DESC: "\uBAA8\uBC14\uC77C \uBC84\uC804 \uD639\uC740 \uB9E4\uC6B0 \uD070 \uC774\uBBF8\uC9C0\uAC00 \uC788\uB294 \uACBD\uC6B0 100%\uB85C \uC124\uC815\uD574\uC57C \uD569\uB2C8\uB2E4.",
  RESET_DEFAULT: "\uAE30\uBCF8\uAC12\uC73C\uB85C \uCD08\uAE30\uD654",
  CARD_MODAL_WIDTH_PERCENT: "\uD50C\uB798\uC2DC\uCE74\uB4DC \uB108\uBE44 \uBE44\uC728",
  RANDOMIZE_CARD_ORDER: "\uB9AC\uBDF0\uC911\uC778 \uCE74\uB4DC\uC758 \uC21C\uC11C\uB97C \uB79C\uB364\uC73C\uB85C \uB450\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Order cards in a deck are displayed during review",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentially within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentially within a deck (All due cards first)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Randomly within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Randomly within a deck (All due cards first)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_DECK_ORDER: "Order decks are displayed during review",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentially (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Randomly (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  DISABLE_CLOZE_CARDS: "\uBE48 \uCE78 \uCC44\uC6B0\uAE30 \uCE74\uB4DC\uB97C \uBE44\uD65C\uC131\uD654\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "==highlights== \uB97C \uBE48 \uCE78 \uCC44\uC6B0\uAE30\uB85C \uC804\uD658\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: '"\uBE48 \uCE78 \uCC44\uC6B0\uAE30 \uD328\uD134" \uC5D0\uC11C <code>${defaultPattern}</code> \uB97C \uCD94\uAC00/\uC81C\uAC70\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?',
  CONVERT_BOLD_TEXT_TO_CLOZES: "**bolded text** \uB97C \uBE48 \uCE78 \uCC44\uC6B0\uAE30\uB85C \uC804\uD658\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: '"\uBE48 \uCE78 \uCC44\uC6B0\uAE30 \uD328\uD134" \uC5D0\uC11C <code>${defaultPattern}</code> \uB97C \uCD94\uAC00/\uC81C\uAC70\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "{{curly brackets}} \uB97C \uBE48 \uCE78 \uCC44\uC6B0\uAE30\uB85C \uC804\uD658\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: '"\uBE48 \uCE78 \uCC44\uC6B0\uAE30 \uD328\uD134" \uC5D0\uC11C <code>${defaultPattern}</code> \uB97C \uCD94\uAC00/\uC81C\uAC70\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?',
  CLOZE_PATTERNS: "\uBE48 \uCE78 \uCC44\uC6B0\uAE30 \uD328\uD134",
  CLOZE_PATTERNS_DESC: '\uBE48 \uCE78 \uCC44\uC6B0\uAE30 \uD328\uD134\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694. \uC904\uBC14\uAFC8\uC73C\uB85C \uAD6C\uBD84\uD569\uB2C8\uB2E4. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "\uC778\uB77C\uC778 \uD50C\uB798\uC2DC\uCE74\uB4DC \uAD6C\uBD84\uC790",
  FIX_SEPARATORS_MANUALLY_WARNING: "\uC8FC\uC758: \uC774 \uC635\uC158\uC744 \uC218\uC815\uD55C \uD6C4\uC5D0\uB294 \uC774\uBBF8 \uC791\uC131\uB41C \uD50C\uB798\uC2DC\uCE74\uB4DC\uB97C \uC218\uB3D9\uC73C\uB85C \uC218\uC815\uD574\uC57C \uD568\uC744 \uC8FC\uC758\uD558\uC2ED\uC2DC\uC624.",
  INLINE_REVERSED_CARDS_SEPARATOR: "\uC778\uB77C\uC778 \uBC18\uC804 \uD50C\uB798\uC2DC\uCE74\uB4DC \uAD6C\uBD84\uC790",
  MULTILINE_CARDS_SEPARATOR: "\uC5EC\uB7EC \uC904 \uD50C\uB798\uC2DC\uCE74\uB4DC \uAD6C\uBD84\uC790",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\uC5EC\uB7EC \uC904 \uBC18\uC804 \uD50C\uB798\uC2DC\uCE74\uB4DC \uAD6C\uBD84\uC790",
  MULTILINE_CARDS_END_MARKER: "\uD074\uB85C\uC988\uC640 \uB2E4\uC911 \uD589 \uD50C\uB798\uC2DC\uCE74\uB4DC\uC758 \uB05D\uC744 \uB098\uD0C0\uB0B4\uB294 \uBB38\uC790",
  NOTES: "\uB178\uD2B8",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Enable note review pane on startup",
  TAGS_TO_REVIEW: "\uB9AC\uBDF0\uC5D0 \uC0AC\uC6A9\uD560 \uD0DC\uADF8",
  TAGS_TO_REVIEW_DESC: "\uD0DC\uADF8\uB97C \uACF5\uBC31 \uB610\uB294 \uBE48 \uC904\uB85C \uAD6C\uBD84\uD574\uC11C \uC785\uB825\uD574\uC8FC\uC138\uC694. \uC608) '#review #tag2 #tag3'",
  OPEN_RANDOM_NOTE: "\uB9AC\uBDF0\uB97C \uC704\uD574 \uB79C\uB364 \uB178\uD2B8\uB97C \uC5FD\uB2C8\uB2E4.",
  OPEN_RANDOM_NOTE_DESC: "\uC774 \uC635\uC158\uC774 \uAEBC\uC838\uC788\uC73C\uBA74, \uB178\uD2B8\uB294 \uC911\uC694\uB3C4(\uD398\uC774\uC9C0 \uB7AD\uD06C)\uC5D0 \uB530\uB77C \uC815\uB82C\uB429\uB2C8\uB2E4.",
  AUTO_NEXT_NOTE: "\uB9AC\uBDF0 \uD6C4\uC5D0 \uB2E4\uC74C \uB178\uD2B8\uB97C \uC790\uB3D9\uC73C\uB85C \uC5FD\uB2C8\uB2E4.",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\uD30C\uC77C \uBA54\uB274\uC5D0\uC11C \uAC80\uD1A0 \uC635\uC158\uC744 \uD65C\uC131\uD654\uD558\uC138\uC694 (\uC608: \uAC80\uD1A0: \uC26C\uC6C0, \uC88B\uC74C, \uC5B4\uB824\uC6C0)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\uD30C\uC77C \uBA54\uB274\uC5D0\uC11C \uAC80\uD1A0 \uC635\uC158\uC744 \uBE44\uD65C\uC131\uD654\uD558\uBA74 \uD50C\uB7EC\uADF8\uC778 \uBA85\uB839\uC744 \uC0AC\uC6A9\uD574 \uB178\uD2B8\uB97C \uAC80\uD1A0\uD560 \uC218 \uC788\uC73C\uBA70, \uC815\uC758\uB41C \uACBD\uC6B0\uC5D0\uB294 \uAD00\uB828\uB41C \uB2E8\uCD95\uD0A4\uB3C4 \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
  MAX_N_DAYS_REVIEW_QUEUE: "\uC624\uB978\uCABD \uD328\uB110\uC5D0 \uD45C\uC2DC\uD560 \uCD5C\uB300 \uC77C\uC218",
  MIN_ONE_DAY: "\uC801\uC5B4\uB3C4 1\uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
  VALID_NUMBER_WARNING: "\uC720\uD6A8\uD55C \uC22B\uC790\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\uB371 \uD2B8\uB9AC\uB294 \uCC98\uC74C\uC5D0 \uD655\uC7A5\uB41C \uAC83\uC73C\uB85C \uD45C\uC2DC\uB418\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "\uAC19\uC740 \uCE74\uB4DC\uC5D0 \uC911\uCCA9\uB41C \uB371\uC744 \uC811\uC73C\uB824\uBA74 \uC774 \uC635\uC158\uC744 \uB044\uC2ED\uC2DC\uC624. \uAC19\uC740 \uD30C\uC77C\uC5D0 \uC5EC\uB7EC \uB371\uC5D0 \uC18D\uD55C \uCE74\uB4DC\uAC00 \uC788\uB294 \uACBD\uC6B0 \uC720\uC6A9\uD569\uB2C8\uB2E4.",
  ALGORITHM: "\uC54C\uACE0\uB9AC\uC998",
  CHECK_ALGORITHM_WIKI: '\uB354 \uB9CE\uC740 \uC815\uBCF4\uB97C \uC6D0\uD558\uC2DC\uBA74, <a href="${algoUrl}">algorithm details</a>\uC744 \uD655\uC778\uD574\uC8FC\uC138\uC694.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "\uAE30\uBCF8 ease",
  BASE_EASE_DESC: "\uCD5C\uC19F\uAC12 = 130, \uC801\uC815\uCE58\uB294 \uB300\uB7B5 250\uC785\uB2C8\uB2E4.",
  BASE_EASE_MIN_WARNING: "\uAE30\uBCF8 ease\uB294 \uC801\uC5B4\uB3C4 130 \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
  LAPSE_INTERVAL_CHANGE: "\uD50C\uB798\uC2DC\uCE74\uB4DC/\uB178\uD2B8\uB97C \uC5B4\uB824\uC6C0(Hard)\uC73C\uB85C \uB9AC\uBDF0\uD588\uC744 \uB54C\uC758 \uAC04\uACA9 \uBCC0\uACBD",
  LAPSE_INTERVAL_CHANGE_DESC: "\uC0C8\uB85C\uC6B4 \uAC04\uACA9 = \uC774\uC804 \uAC04\uACA9 * \uAC04\uACA9\uBCC0\uACBD \uAC12 / 100.",
  EASY_BONUS: "\uC26C\uC6C0(Easy) \uBCF4\uB108\uC2A4",
  EASY_BONUS_DESC: "\uC26C\uC6C0(Easy) \uBCF4\uB108\uC2A4\uB294 \uD50C\uB798\uC2DC\uCE74\uB4DC/\uB178\uD2B8\uC5D0\uC11C \uC88B\uC74C(Good)\uACFC \uC26C\uC6C0(Easy) \uC0AC\uC774\uC758 \uAC04\uACA9 \uCC28\uC774\uB97C \uC124\uC815\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4. (\uCD5C\uC18C = 100%)",
  EASY_BONUS_MIN_WARNING: "\uC26C\uC6C0(Easy) \uBCF4\uB108\uC2A4\uB294 \uC801\uC5B4\uB3C4 100\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maximum interval in days",
  MAX_INTERVAL_DESC: "\uAC04\uACA9\uC758 \uC0C1\uD55C\uC120\uC744 \uB458 \uC218 \uC788\uC2B5\uB2C8\uB2E4. (\uAE30\uBCF8\uAC12 = 100\uB144)",
  MAX_INTERVAL_MIN_WARNING: "\uCD5C\uB300 \uAC04\uACA9\uC740 \uC801\uC5B4\uB3C4 1\uC77C\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
  MAX_LINK_CONTRIB: "\uCD5C\uB300 \uC5F0\uACB0 \uAE30\uC5EC\uB3C4",
  MAX_LINK_CONTRIB_DESC: "\uB9C1\uD06C\uB41C \uB178\uD2B8\uC758 \uCD08\uAE30 ease\uC5D0 \uB300\uD55C \uAC00\uC911\uCE58\uAC00 \uC801\uC6A9\uB41C ease\uC758 \uCD5C\uB300 \uAE30\uC5EC\uB3C4\uC785\uB2C8\uB2E4.",
  LOGGING: "\uB85C\uAE45",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\uB514\uBC84\uAE45 \uC815\uBCF4\uB97C \uAC1C\uBC1C\uC790 \uCF58\uC194\uC5D0 \uD45C\uC2DC\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\uB9AC\uBDF0\uD560 \uB178\uD2B8 \uB300\uAE30\uC5F4",
  CLOSE: "\uB2EB\uAE30",
  NEW: "New",
  YESTERDAY: "\uC5B4\uC81C",
  TODAY: "\uC624\uB298",
  TOMORROW: "\uB0B4\uC77C",
  // stats-modal.tsx
  STATS_TITLE: "\uD1B5\uACC4",
  MONTH: "\uC6D4",
  QUARTER: "\uBD84\uAE30",
  YEAR: "\uB144",
  LIFETIME: "\uD3C9\uC0DD",
  FORECAST: "\uC608\uCE21",
  FORECAST_DESC: "\uC774\uD6C4\uC5D0 \uD559\uC2B5\uD560 \uCE74\uB4DC\uC758 \uC218",
  SCHEDULED: "Scheduled",
  DAYS: "\uC77C",
  NUMBER_OF_CARDS: "\uCE74\uB4DC\uC758 \uC218",
  REVIEWS_PER_DAY: "\uD3C9\uADE0: ${avg} \uB9AC\uBDF0/\uC77C",
  INTERVALS: "\uAC04\uACA9",
  INTERVALS_DESC: "\uB9AC\uBDF0\uB97C \uB2E4\uC2DC \uD560 \uB54C \uAE4C\uC9C0\uC758 \uAE30\uAC04",
  COUNT: "Count",
  INTERVALS_SUMMARY: "\uD3C9\uADE0 \uAC04\uACA9: ${avg}, \uAC00\uC7A5 \uAE34 \uAC04\uACA9: ${longest}",
  EASES: "Eases",
  EASES_SUMMARY: "Average ease: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "\uCE74\uB4DC \uD0C0\uC785",
  CARD_TYPES_DESC: "\uC5EC\uAE30\uC5D0\uB294 \uBB3B\uC5B4\uB454 \uCE74\uB4DC\uB3C4 \uD3EC\uD568\uB429\uB2C8\uB2E4.",
  CARD_TYPE_NEW: "New",
  CARD_TYPE_YOUNG: "Young",
  CARD_TYPE_MATURE: "Mature",
  CARD_TYPES_SUMMARY: "\uC804\uCCB4 \uCE74\uB4DC \uC218: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var ko_default = ko;

// src/lang/locale/mr.ts
var mr = {
  ...en_default,
  language: "mr",
  languageName: "Marathi"
};
var mr_default = mr;

// src/lang/locale/nl.ts
var nl = {
  ...en_default,
  language: "nl",
  languageName: "Nederlands",
  // flashcard-modal.tsx
  DECKS: "Stapel",
  DUE_CARDS: "Te beoordelen kaarten",
  NEW_CARDS: "Nieuwe kaarten",
  TOTAL_CARDS: "Totaal aantal kaarten",
  BACK: "Terug",
  SKIP: "Overslaan",
  EDIT_CARD: "Kaart bewerken",
  RESET_CARD_PROGRESS: "Voortgang van kaart resetten",
  HARD: "Moeilijk",
  GOOD: "Goed",
  EASY: "Gemakkelijk",
  SHOW_ANSWER: "Toon antwoord",
  CARD_PROGRESS_RESET: "Voortgang van kaart is gereset.",
  SAVE: "Opslaan",
  CANCEL: "Annuleren",
  NO_INPUT: "Geen invoer opgegeven.",
  CURRENT_EASE_HELP_TEXT: "Huidige Moeilijkheid: ",
  CURRENT_INTERVAL_HELP_TEXT: "Huidige Interval: ",
  CARD_GENERATED_FROM: "Gegenereerd van: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Open een notitie voor beoordeling",
  REVIEW_CARDS: "Beoordeel flitskaarten",
  REVIEW_DIFFICULTY_FILE_MENU: "Beoordelen: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Beoordeel notitie als ${difficulty}",
  CRAM_ALL_CARDS: "Selecteer een stapel om te stampen",
  REVIEW_ALL_CARDS: "Beoordeel flitskaarten van alle notities",
  REVIEW_CARDS_IN_NOTE: "Beoordeel flitskaarten in deze notitie",
  CRAM_CARDS_IN_NOTE: "Stamp flitskaarten in deze notitie",
  VIEW_STATS: "Bekijk statistieken",
  OPEN_REVIEW_QUEUE_VIEW: "Open notities beoordelingswachtrij in zijbalk",
  STATUS_BAR: "Beoordeling: ${dueNotesCount} notitie(s), ${dueFlashcardsCount} kaart(en) te beoordelen",
  SYNC_TIME_TAKEN: "Synchronisatie duurde ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "Notitie is opgeslagen in een genegeerde map (controleer instellingen).",
  PLEASE_TAG_NOTE: "Tag de notitie correct voor beoordeling (in instellingen).",
  RESPONSE_RECEIVED: "Reactie ontvangen.",
  NO_DECK_EXISTS: "Er bestaat geen stapel voor ${deckName}",
  ALL_CAUGHT_UP: "Je bent nu helemaal bij :D.",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} dag(en)",
  MONTHS_STR_IVL: "${interval} maand(en)",
  YEARS_STR_IVL: "${interval} jaar",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}j",
  // settings.ts
  SETTINGS_HEADER: "Gespreide Herhaling",
  GROUP_TAGS_FOLDERS: "Tags & Mappen",
  GROUP_FLASHCARD_REVIEW: "Flitskaart Beoordeling",
  GROUP_FLASHCARD_SEPARATORS: "Flitskaart Scheidingstekens",
  GROUP_DATA_STORAGE: "Opslag van planningsgegevens",
  GROUP_DATA_STORAGE_DESC: "Kies waar de planningsgegevens worden opgeslagen",
  GROUP_FLASHCARDS_NOTES: "Flitskaarten & Notities",
  GROUP_CONTRIBUTING: "Bijdragen",
  CHECK_WIKI: 'Voor meer informatie, bekijk de <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Bezoek de <a href="${discussionsUrl}">discussies</a> sectie voor Q&A hulp, feedback, en algemene discussie.',
  GITHUB_ISSUES: 'Meld een probleem <a href="${issuesUrl}">hier</a> als je een functieverzoek of een bugrapport hebt.',
  GITHUB_SOURCE_CODE: 'De broncode van het project is beschikbaar op <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Hier</a> lees je hoe je code kunt bijdragen aan de plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Hier</a> lees je hoe je de plugin in een andere taal kunt vertalen.',
  FOLDERS_TO_IGNORE: "Mappen om te negeren",
  FOLDERS_TO_IGNORE_DESC: "Voer mappaden of globpatronen in op aparte regels, bijvoorbeeld Templates/Scripts of **/*.excalidraw.md. Deze instelling is gemeenschappelijk voor zowel flitskaarten als notities.",
  OBSIDIAN_INTEGRATION: "Integratie in Obsidian",
  FLASHCARDS: "Flitskaarten",
  FLASHCARD_EASY_LABEL: "Gemakkelijk-knoptekst",
  FLASHCARD_GOOD_LABEL: "Goed-knoptekst",
  FLASHCARD_HARD_LABEL: "Moeilijk-knoptekst",
  FLASHCARD_EASY_DESC: 'Pas het label aan voor de "Gemakkelijk" knop',
  FLASHCARD_GOOD_DESC: 'Pas het label aan voor de "Goed" knop',
  FLASHCARD_HARD_DESC: 'Pas het label aan voor de "Moeilijk" knop',
  REVIEW_BUTTON_DELAY: "Vertraging knopindrukken (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Voeg een vertraging toe aan de beoordelingsknoppen voordat ze opnieuw kunnen worden ingedrukt.",
  FLASHCARD_TAGS: "Flitskaarttags",
  FLASHCARD_TAGS_DESC: "Voer tags in, gescheiden door spaties of nieuwe regels, bijvoorbeeld #flitskaarten #stapel2 #stapel3.",
  CONVERT_FOLDERS_TO_DECKS: "Converteer mappen naar stapels en substapels",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Dit is een alternatief voor de optie flitskaarttags hierboven.",
  INLINE_SCHEDULING_COMMENTS: "Planningsopmerking opslaan op dezelfde regel als de laatste regel van de flitskaart?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Als u dit inschakelt, wordt de opmaak van de lijst niet verbroken door de HTML-opmerkingen.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Begraaf de broer-/zuskaarten tot de volgende dag",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Broer-/zuskaarten zijn kaarten die zijn gegenereerd uit dezelfde kaarttekst, bijvoorbeeld cloze-deleties",
  SHOW_CARD_CONTEXT: "Toon context in kaarten",
  SHOW_CARD_CONTEXT_DESC: "Bijv. Titel > Kop 1 > Subkop > ... > Subkop",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Toon volgende herzieningstijd in de beoordelingsknoppen",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Handig om te weten hoe ver in de toekomst je kaarten worden uitgesteld.",
  CARD_MODAL_HEIGHT_PERCENT: "Flitskaart hoogtepercentage",
  CARD_MODAL_SIZE_PERCENT_DESC: "Moet worden ingesteld op 100% op mobiel of als je zeer grote afbeeldingen hebt",
  RESET_DEFAULT: "Reset naar standaard",
  CARD_MODAL_WIDTH_PERCENT: "Flitskaart breedtepercentage",
  RANDOMIZE_CARD_ORDER: "Flitskaartvolgorde willekeurig tijdens herziening?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Volgorde van kaarten in een stapel tijdens herziening",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Opeenvolgend binnen een stapel (Alle nieuwe kaarten eerst)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Opeenvolgend binnen een stapel (Alle kaarten die aan de beurt zijn eerst)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Willekeurig binnen een stapel (Alle nieuwe kaarten eerst)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Willekeurig binnen een stapel (Alle kaarten die aan de beurt zijn eerst)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Willekeurige kaart uit willekeurige stapel",
  REVIEW_DECK_ORDER: "Volgorde waarin stapels worden weergegeven tijdens herziening",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Opeenvolgend (als alle kaarten in de vorige stapel zijn herzien)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Willekeurig (als alle kaarten in de vorige stapel zijn herzien)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Willekeurige kaart uit willekeurige stapel",
  DISABLE_CLOZE_CARDS: "Cloze-kaarten uitschakelen?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "Converteer ==highlights== naar clozes",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'Voeg de <code>${defaultPattern}</code> toe aan/verwijder deze uit uw "Cloze-patronen"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "Converteer **vetgedrukte tekst** naar clozes",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'Voeg de <code>${defaultPattern}</code> toe aan/verwijder deze uit uw "Cloze-patronen"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "Converteer {{accolades}} naar clozes",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'Voeg de <code>${defaultPattern}</code> toe aan/verwijder deze uit uw "Cloze-patronen"',
  CLOZE_PATTERNS: "Cloze-patronen",
  CLOZE_PATTERNS_DESC: 'Voer cloze-patronen in, gescheiden door nieuwe regels. Raadpleeg de <a href="${docsUrl}">wiki</a> voor meer informatie.',
  INLINE_CARDS_SEPARATOR: "Scheidingsteken voor inline flitskaarten",
  FIX_SEPARATORS_MANUALLY_WARNING: "Houd er rekening mee dat u na het wijzigen hiervan handmatig alle flitskaarten die u al hebt, moet bewerken.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Scheidingsteken voor inline omgekeerde flitskaarten",
  MULTILINE_CARDS_SEPARATOR: "Scheidingsteken voor meerregelige flitskaarten",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Scheidingsteken voor meerregelige omgekeerde flitskaarten",
  MULTILINE_CARDS_END_MARKER: "Tekens die het einde van clozes en meerregelige flitskaarten aangeven",
  NOTES: "Notities",
  NOTE: "Notitie",
  REVIEW_PANE_ON_STARTUP: "Notitiebeoordelingsvenster inschakelen bij opstarten",
  TAGS_TO_REVIEW: "Tags om te beoordelen",
  TAGS_TO_REVIEW_DESC: "Voer tags in, gescheiden door spaties of nieuwe regels, bijv. #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "Open een willekeurige notitie voor beoordeling",
  OPEN_RANDOM_NOTE_DESC: "Wanneer u dit uitschakelt, worden notities geordend op belangrijkheid (PageRank).",
  AUTO_NEXT_NOTE: "Open automatisch de volgende notitie na een beoordeling",
  MAX_N_DAYS_REVIEW_QUEUE: "Maximum aantal dagen om weer te geven in het notitiebeoordelingspaneel",
  MIN_ONE_DAY: "Het aantal dagen moet minimaal 1 zijn.",
  VALID_NUMBER_WARNING: "Geef een geldig getal op.",
  UI: "Gebruikersinterface",
  OPEN_IN_TAB: "Open in nieuw tabblad",
  OPEN_IN_TAB_DESC: "Schakel dit uit om de plugin in een modaal venster te openen",
  SHOW_STATUS_BAR: "Statusbalk weergeven",
  SHOW_STATUS_BAR_DESC: "Schakel dit uit om de beoordelingsstatus van de flitskaart te verbergen in de statusbalk van Obsidian",
  SHOW_RIBBON_ICON: "Pictogram weergeven in de lintbalk",
  SHOW_RIBBON_ICON_DESC: "Schakel dit uit om het pictogram van de plugin in de lintbalk van Obsidian te verbergen",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Schakel de beoordelingsopties in het bestandsmenu in (bijv. Beoordelen: Gemakkelijk, Goed, Moeilijk)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Schakel deze optie uit om uw notities te beoordelen met behulp van de plugin-opdrachten en, indien gedefinieerd, de bijbehorende sneltoetsen voor opdrachten.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Stapelstructuren: Vouw substapels aanvankelijk uit",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Schakel dit uit om geneste stapels in dezelfde kaart samen te vouwen. Handig als je kaarten hebt die tot meerdere stapels in hetzelfde bestand behoren.",
  ALGORITHM: "Algoritme",
  CHECK_ALGORITHM_WIKI: 'Voor meer informatie, bekijk de <a href="${algoUrl}">algoritmedetails</a>.',
  SM2_OSR_VARIANT: "OSR's variant van SM-2",
  BASE_EASE: "Basisgemak",
  BASE_EASE_DESC: "minimum = 130, bij voorkeur ongeveer 250.",
  BASE_EASE_MIN_WARNING: "Het basisgemak moet minimaal 130 zijn.",
  LAPSE_INTERVAL_CHANGE: "Intervalwijziging wanneer u een flitskaart/notitie als moeilijk beoordeelt",
  LAPSE_INTERVAL_CHANGE_DESC: "nieuwInterval = oudInterval * intervalWijziging / 100.",
  EASY_BONUS: "Gemakkelijk Bonus",
  EASY_BONUS_DESC: "De Gemakkelijk Bonus stelt u in staat het verschil in intervallen in te stellen tussen het beantwoorden van Goed en Gemakkelijk op een flitskaart/notitie (minimum = 100%).",
  EASY_BONUS_MIN_WARNING: "De Gemakkelijk Bonus moet minimaal 100 zijn.",
  LOAD_BALANCE: "Schakel load balancer in",
  LOAD_BALANCE_DESC: `Het interval wordt iets aangepast, zodat het aantal beoordelingen per dag consistenter is.
        Het is vergelijkbaar met Anki's fuzz, maar in plaats van willekeurig te zijn, kiest het de dag met het minste aantal beoordelingen.
        Het is uitgeschakeld voor kleine intervallen.`,
  MAX_INTERVAL: "Maximum interval in dagen",
  MAX_INTERVAL_DESC: "Hiermee kunt u een bovengrens voor het interval instellen (standaard = 100 jaar).",
  MAX_INTERVAL_MIN_WARNING: "Het maximale interval moet minimaal 1 dag zijn.",
  MAX_LINK_CONTRIB: "Maximale linkbijdrage",
  MAX_LINK_CONTRIB_DESC: "Maximale bijdrage van de gewogen gemak van gekoppelde notities aan het initi\xEBle gemak.",
  LOGGING: "Loggen",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Toon de foutopsporingsinformatie van de planner op de ontwikkelaarsconsole",
  DISPLAY_PARSER_DEBUG_INFO: "Toon de foutopsporingsinformatie van de parser op de ontwikkelaarsconsole",
  SCHEDULING: "Plannen",
  EXPERIMENTAL: "Experimenteel",
  HELP: "Help",
  STORE_IN_NOTES: "In de notities",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Notities beoordelingswachtrij",
  CLOSE: "Sluiten",
  NEW: "Nieuw",
  YESTERDAY: "Gisteren",
  TODAY: "Vandaag",
  TOMORROW: "Morgen",
  // stats-modal.tsx
  STATS_TITLE: "Statistieken",
  MONTH: "Maand",
  QUARTER: "Kwartaal",
  YEAR: "Jaar",
  LIFETIME: "Levensduur",
  FORECAST: "Voorspelling",
  FORECAST_DESC: "Het aantal kaarten dat in de toekomst aan de beurt is",
  SCHEDULED: "Gepland",
  DAYS: "Dagen",
  NUMBER_OF_CARDS: "Aantal kaarten",
  REVIEWS_PER_DAY: "Gemiddeld: ${avg} beoordelingen/dag",
  INTERVALS: "Intervallen",
  INTERVALS_DESC: "Vertragingen totdat beoordelingen opnieuw worden weergegeven",
  COUNT: "Aantal",
  INTERVALS_SUMMARY: "Gemiddeld interval: ${avg}, Langste interval: ${longest}",
  EASES: "Gemakken",
  EASES_SUMMARY: "Gemiddeld gemak: ${avgEase}",
  EASE: "Gemak",
  CARD_TYPES: "Kaarttypen",
  CARD_TYPES_DESC: "Dit omvat ook begraven kaarten, indien aanwezig",
  CARD_TYPE_NEW: "Nieuw",
  CARD_TYPE_YOUNG: "Jong",
  CARD_TYPE_MATURE: "Volwassen",
  CARD_TYPES_SUMMARY: "Totaal aantal kaarten: ${totalCardsCount}",
  SEARCH: "Zoeken",
  PREVIOUS: "Vorige",
  NEXT: "Volgende",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var nl_default = nl;

// src/lang/locale/no.ts
var no = {
  ...en_default,
  language: "no",
  languageName: "Norsk"
};
var no_default = no;

// src/lang/locale/pl.ts
var pl = {
  ...en_default,
  // flashcard-modal.tsx
  language: "pl",
  languageName: "Polski",
  DECKS: "Talie",
  DUE_CARDS: "Fiszki z terminem",
  NEW_CARDS: "Nowe fiszki",
  TOTAL_CARDS: "Wszystkie karty",
  BACK: "Wstecz",
  SKIP: "Pomi\u0144",
  EDIT_CARD: "Edytuj kart\u0119",
  RESET_CARD_PROGRESS: "Zresetuj post\u0119p karty",
  HARD: "Trudne",
  GOOD: "\u015Arednio Trudne",
  EASY: "\u0141atwe",
  SHOW_ANSWER: "Poka\u017C odpowied\u017A",
  CARD_PROGRESS_RESET: "Post\u0119p karty zosta\u0142 zresetowany.",
  SAVE: "Zapisz",
  CANCEL: "Anuluj",
  NO_INPUT: "Nie wprowadzono warto\u015Bci.",
  CURRENT_EASE_HELP_TEXT: "Aktualna \u0142atwo\u015B\u0107: ",
  CURRENT_INTERVAL_HELP_TEXT: "Aktualny interwa\u0142: ",
  CARD_GENERATED_FROM: "Wygenerowano z: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Otw\xF3rz notatk\u0119 do przegl\u0105du",
  REVIEW_CARDS: "Przegl\u0105daj fiszki",
  REVIEW_DIFFICULTY_FILE_MENU: "Przegl\u0105daj: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Przegl\u0105daj notatk\u0119 jako ${difficulty}",
  CRAM_ALL_CARDS: "Wybierz tali\u0119 do intensywnego uczenia",
  REVIEW_ALL_CARDS: "Przegl\u0105daj fiszki ze wszystkich notatek",
  REVIEW_CARDS_IN_NOTE: "Przegl\u0105daj fiszki w tej notatce",
  CRAM_CARDS_IN_NOTE: "Intensywne uczenie fiszek w tej notatce",
  VIEW_STATS: "Wy\u015Bwietl statystyki",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "Przegl\u0105daj: ${dueNotesCount} notatek, ${dueFlashcardsCount} fiszek z terminem",
  SYNC_TIME_TAKEN: "Synchronizacja zaj\u0119\u0142a ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "Notatka jest zapisana w folderze zignorowanym (sprawd\u017A ustawienia).",
  PLEASE_TAG_NOTE: "Prosz\u0119 odpowiednio otagowa\u0107 notatk\u0119 do przegl\u0105du (w ustawieniach).",
  RESPONSE_RECEIVED: "Otrzymano odpowied\u017A.",
  NO_DECK_EXISTS: "Nie istnieje talia o nazwie ${deckName}",
  ALL_CAUGHT_UP: "Jeste\u015B teraz na bie\u017C\u0105co :D.",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} dni",
  MONTHS_STR_IVL: "${interval} miesi\u0119cy",
  YEARS_STR_IVL: "${interval} lata",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}r",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: 'Aby uzyska\u0107 wi\u0119cej informacji, sprawd\u017A <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Foldery do zignorowania",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Fiszki",
  FLASHCARD_EASY_LABEL: "Tekst przycisku \u0141atwe",
  FLASHCARD_GOOD_LABEL: "Tekst przycisku \u015Arednio trudne",
  FLASHCARD_HARD_LABEL: "Tekst przycisku Trudne",
  FLASHCARD_EASY_DESC: 'Dostosuj etykiet\u0119 dla przycisku "\u0141atwe"',
  FLASHCARD_GOOD_DESC: 'Dostosuj etykiet\u0119 dla przycisku "\u015Arednio trudne"',
  FLASHCARD_HARD_DESC: 'Dostosuj etykiet\u0119 dla przycisku "Trudne"',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Tagi fiszek",
  FLASHCARD_TAGS_DESC: "Wprowad\u017A tagi oddzielone spacj\u0105 lub nowymi liniami, np. #fiszki #talia2 #talia3.",
  CONVERT_FOLDERS_TO_DECKS: "Czy konwertowa\u0107 foldery na talie i podtalie?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Jest to alternatywa dla opcji tag\xF3w fiszek powy\u017Cej.",
  INLINE_SCHEDULING_COMMENTS: "Czy zachowa\u0107 komentarz harmonogramowania w tej samej linii co ostatnia linia fiszki?",
  INLINE_SCHEDULING_COMMENTS_DESC: "W\u0142\u0105czenie tej opcji sprawi, \u017Ce komentarze HTML nie b\u0119d\u0105 przerywa\u0107 formatowania listy.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Czy ukrywa\u0107 karty rodze\u0144stwa do nast\u0119pnego dnia?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Rodze\u0144stwo to karty wygenerowane z tego samego tekstu karty, np. usuni\u0119cia zamaskowane",
  SHOW_CARD_CONTEXT: "Czy pokazywa\u0107 kontekst na kartach?",
  SHOW_CARD_CONTEXT_DESC: "np. Tytu\u0142 > Nag\u0142\xF3wek 1 > Podnag\u0142\xF3wek > ... > Podnag\u0142\xF3wek",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "Procentowa wysoko\u015B\u0107 fiszki",
  CARD_MODAL_SIZE_PERCENT_DESC: "Powinno by\u0107 ustawione na 100% na urz\u0105dzeniach mobilnych lub gdy masz bardzo du\u017Ce obrazy",
  RESET_DEFAULT: "Zresetuj do domy\u015Blnych",
  CARD_MODAL_WIDTH_PERCENT: "Procentowa szeroko\u015B\u0107 fiszki",
  RANDOMIZE_CARD_ORDER: "Czy losowa\u0107 kolejno\u015B\u0107 kart podczas przegl\u0105du?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Kolejno\u015B\u0107 kart w talii wy\u015Bwietlana podczas przegl\u0105dania",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Kolejno w ramach talii (Najpierw wszystkie nowe karty)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Kolejno w ramach talii (Najpierw wszystkie karty z terminem)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Losowo w ramach talii (Najpierw wszystkie nowe karty)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Losowo w ramach talii (Najpierw wszystkie karty z terminem)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Losowa karta z losowej talii",
  REVIEW_DECK_ORDER: "Kolejno\u015B\u0107 talii wy\u015Bwietlana podczas przegl\u0105dania",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Kolejno (gdy wszystkie karty w poprzedniej talii przegl\u0105dni\u0119te)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Losowo (gdy wszystkie karty w poprzedniej talii przegl\u0105dni\u0119te)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Losowa karta z losowej talii",
  DISABLE_CLOZE_CARDS: "Wy\u0142\u0105czy\u0107 karty zamaskowane?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "Konwertowa\u0107 ==pod\u015Bwietlenia== na karty zamaskowane?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'Dodaj/usu\u0144 <code>${defaultPattern}</code> z "Wzory kart zamaskowanych"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "Konwertowa\u0107 pogrubiony tekst na karty zamaskowane?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'Dodaj/usu\u0144 <code>${defaultPattern}</code> z "Wzory kart zamaskowanych"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "Konwertowa\u0107 {{klamry}} na karty zamaskowane?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'Dodaj/usu\u0144 <code>${defaultPattern}</code> z "Wzory kart zamaskowanych"',
  CLOZE_PATTERNS: "Wzory kart zamaskowanych",
  CLOZE_PATTERNS_DESC: 'Wprowad\u017A wzory kart zamaskowanych oddzielone nowymi liniami. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Separator dla kart zamaskowanych w linii",
  FIX_SEPARATORS_MANUALLY_WARNING: "Pami\u0119taj, \u017Ce po zmianie tego musisz r\u0119cznie edytowa\u0107 wszystkie karty zamaskowane, kt\xF3re ju\u017C masz.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Separator dla kart zamaskowanych odwr\xF3conych w linii",
  MULTILINE_CARDS_SEPARATOR: "Separator dla kart zamaskowanych wieloliniowych",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Separator dla kart zamaskowanych odwr\xF3conych wieloliniowych",
  MULTILINE_CARDS_END_MARKER: "Caracteres que denotam o fim de clozes e flashcards multilineares",
  NOTES: "Notatki",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "W\u0142\u0105czy\u0107 panel przegl\u0105du notatek przy starcie",
  TAGS_TO_REVIEW: "Tagi do przegl\u0105du",
  TAGS_TO_REVIEW_DESC: "Wprowad\u017A tagi oddzielone spacj\u0105 lub nowymi liniami, np. #przegl\u0105d #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "Otw\xF3rz losow\u0105 notatk\u0119 do przegl\u0105du",
  OPEN_RANDOM_NOTE_DESC: "Po wy\u0142\u0105czeniu tej opcji notatki s\u0105 uporz\u0105dkowane wed\u0142ug istotno\u015Bci (PageRank).",
  AUTO_NEXT_NOTE: "Automatycznie otwiera\u0107 nast\u0119pn\u0105 notatk\u0119 po przegl\u0105dzie",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Wy\u0142\u0105czy\u0107 opcje przegl\u0105du w menu pliku, tj. Przegl\u0105daj: \u0141atwe Dobrze Trudne",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Je\u015Bli wy\u0142\u0105czysz opcje przegl\u0105du w menu Plik, mo\u017Cesz przegl\u0105da\u0107 swoje notatki za pomoc\u0105 polece\u0144 wtyczki i, je\u015Bli je zdefiniowa\u0142e\u015B, przypisanych skr\xF3t\xF3w klawiszowych.",
  MAX_N_DAYS_REVIEW_QUEUE: "Maksymalna liczba dni do wy\u015Bwietlenia w panelu prawym",
  MIN_ONE_DAY: "Liczba dni musi wynosi\u0107 co najmniej 1.",
  VALID_NUMBER_WARNING: "Podaj prawid\u0142ow\u0105 liczb\u0119.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Podtalie powinny by\u0107 pocz\u0105tkowo wy\u015Bwietlane rozszerzone",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Wy\u0142\u0105cz to, aby zwin\u0105\u0107 zagnie\u017Cd\u017Cone talie w tej samej karcie. Przydatne, je\u015Bli karty nale\u017C\u0105 do wielu talii w tym samym pliku.",
  ALGORITHM: "Algorytm",
  CHECK_ALGORITHM_WIKI: 'Aby uzyska\u0107 wi\u0119cej informacji, sprawd\u017A <a href="${algoUrl}">implementacj\u0119 algorytmu</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Podstawowa \u0142atwo\u015B\u0107",
  BASE_EASE_DESC: "minimum = 130, preferowana warto\u015B\u0107 to oko\u0142o 250.",
  BASE_EASE_MIN_WARNING: "Podstawowa \u0142atwo\u015B\u0107 musi wynosi\u0107 co najmniej 130.",
  LAPSE_INTERVAL_CHANGE: "Zmiana interwa\u0142u podczas przegl\u0105dania fiszki/notatki jako trudne",
  LAPSE_INTERVAL_CHANGE_DESC: "nowyInterwa\u0142 = staryInterwa\u0142 * zmianaInterwa\u0142u / 100.",
  EASY_BONUS: "Bonus za \u0142atwe",
  EASY_BONUS_DESC: "Bonus za \u0142atwe pozwala ustawi\u0107 r\xF3\u017Cnic\u0119 w interwa\u0142ach mi\u0119dzy odpowiedziami \u015Arednio trudne i \u0141atwe na fiszce/notatce (minimum = 100%).",
  EASY_BONUS_MIN_WARNING: "Bonus za \u0142atwe musi wynosi\u0107 co najmniej 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maksymalny interwa\u0142 w dniach",
  MAX_INTERVAL_DESC: "Pozwala na ustawienie g\xF3rnego limitu interwa\u0142u (domy\u015Blnie = 100 lat).",
  MAX_INTERVAL_MIN_WARNING: "Maksymalny interwa\u0142 musi wynosi\u0107 co najmniej 1 dzie\u0144.",
  MAX_LINK_CONTRIB: "Maksymalny wk\u0142ad \u0142\u0105cza",
  MAX_LINK_CONTRIB_DESC: "Maksymalny wk\u0142ad wa\u017Conej \u0142atwo\u015Bci po\u0142\u0105czonych notatek do pocz\u0105tkowej \u0142atwo\u015Bci.",
  LOGGING: "Logowanie",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Wy\u015Bwietl informacje debugowania w konsoli deweloperskiej",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Kolejka przegl\u0105du notatek",
  CLOSE: "Zamknij",
  NEW: "Nowe",
  YESTERDAY: "Wczoraj",
  TODAY: "Dzisiaj",
  TOMORROW: "Jutro",
  // stats-modal.tsx
  STATS_TITLE: "Statystyki",
  MONTH: "Miesi\u0105c",
  QUARTER: "Kwarta\u0142",
  YEAR: "Rok",
  LIFETIME: "Ca\u0142e \u017Cycie",
  FORECAST: "Prognoza",
  FORECAST_DESC: "Liczba kart z terminem w przysz\u0142o\u015Bci",
  SCHEDULED: "Zaplanowane",
  DAYS: "Dni",
  NUMBER_OF_CARDS: "Liczba kart",
  REVIEWS_PER_DAY: "\u015Arednio: ${avg} przegl\u0105d\xF3w/dzie\u0144",
  INTERVALS: "Interwa\u0142y",
  INTERVALS_DESC: "Op\xF3\u017Anienia przed ponownym pokazaniem przegl\u0105d\xF3w",
  COUNT: "Liczba",
  INTERVALS_SUMMARY: "\u015Aredni interwa\u0142: ${avg}, Najd\u0142u\u017Cszy interwa\u0142: ${longest}",
  EASES: "\u0141atwo\u015Bci",
  EASES_SUMMARY: "\u015Arednia \u0142atwo\u015B\u0107: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Typy kart",
  CARD_TYPES_DESC: "Obejmuje tak\u017Ce ukryte karty, je\u015Bli takie s\u0105",
  CARD_TYPE_NEW: "Nowe",
  CARD_TYPE_YOUNG: "M\u0142ode",
  CARD_TYPE_MATURE: "Stare",
  CARD_TYPES_SUMMARY: "\u0141\u0105czna liczba kart: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var pl_default = pl;

// src/lang/locale/pt.ts
var pt = {
  ...en_default,
  language: "pt",
  languageName: "Portugu\xEAs"
};
var pt_default = pt;

// src/lang/locale/pt-br.ts
var ptBR = {
  ...en_default,
  language: "pt-br",
  languageName: "Portugu\xEAs do Brasil",
  // flashcard-modal.tsx
  DECKS: "Baralhos",
  DUE_CARDS: "Cartas para Colocar em Dia",
  NEW_CARDS: "Novas Cartas",
  TOTAL_CARDS: "Total de Cartas",
  BACK: "Voltar",
  SKIP: "Pular",
  EDIT_CARD: "Editar Cart\xE3o",
  RESET_CARD_PROGRESS: "Reiniciar o Progresso da Carta",
  HARD: "Dif\xEDcil",
  GOOD: "OK",
  EASY: "F\xE1cil",
  SHOW_ANSWER: "Mostrar Resposta",
  CARD_PROGRESS_RESET: "O Progresso da Carta foi reiniciado",
  SAVE: "Salvar",
  CANCEL: "Cancelar",
  NO_INPUT: "Nenhuma entrada fornecida.",
  CURRENT_EASE_HELP_TEXT: "Facilidade atual: ",
  CURRENT_INTERVAL_HELP_TEXT: "Intervalo atual: ",
  CARD_GENERATED_FROM: "Gerada a partir de: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "Abrir uma nota para revisar",
  REVIEW_CARDS: "Revisar flashcards",
  REVIEW_DIFFICULTY_FILE_MENU: "Revis\xE3o: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Revisar nota como ${difficulty}",
  REVIEW_ALL_CARDS: "Revisar flashcards de todas as notas",
  CRAM_ALL_CARDS: "Selecione um baralho para revisar",
  REVIEW_CARDS_IN_NOTE: "Revisar flashcards nessa nota",
  CRAM_CARDS_IN_NOTE: "Revisar todas as flashcards nessa nota",
  VIEW_STATS: "Ver estat\xEDsticas",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "Revis\xE3o: ${dueNotesCount} nota(s), ${dueFlashcardsCount} Carta(s) para colocar em dia",
  SYNC_TIME_TAKEN: "Sincroniza\xE7\xE3o levou ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "Nota \xE9 salva na pasta ignorada (cheque as configura\xE7\xF5es).",
  PLEASE_TAG_NOTE: "Por favor etiquete a nota apropriadamente para revisar (nas configura\xE7\xF5es).",
  RESPONSE_RECEIVED: "Resposta recebida.",
  NO_DECK_EXISTS: "Nenhum baralho existe para ${deckName}",
  ALL_CAUGHT_UP: "Voc\xEA colocou tudo em dia agora :D.",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} dia(s)",
  MONTHS_STR_IVL: "${interval} m\xEAs(es)",
  YEARS_STR_IVL: "${interval} ano(s)",
  DAYS_STR_IVL_MOBILE: "${interval}d",
  MONTHS_STR_IVL_MOBILE: "${interval}m",
  YEARS_STR_IVL_MOBILE: "${interval}a",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: 'Para mais informa\xE7\xF5es, cheque a <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "Pastas para ignorar",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Flashcards",
  FLASHCARD_EASY_LABEL: "Texto do Bot\xE3o de F\xE1cil",
  FLASHCARD_GOOD_LABEL: "Texto do Bot\xE3o de OK",
  FLASHCARD_HARD_LABEL: "Texto do Bot\xE3o de Dif\xEDcil",
  FLASHCARD_EASY_DESC: 'Customize o r\xF3tulo para o bot\xE3o de "F\xE1cil"',
  FLASHCARD_GOOD_DESC: 'Customize o r\xF3tulo para o bot\xE3o de "OK"',
  FLASHCARD_HARD_DESC: 'Customize o r\xF3tulo para o bot\xE3o de "Dif\xEDcil"',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Etiquetas dos Flashcards",
  FLASHCARD_TAGS_DESC: "Insira etiquetas separadas por espa\xE7os ou quebras de linha ex: #flashcards #baralho2 #baralho3.",
  CONVERT_FOLDERS_TO_DECKS: "Converter pastas para baralhos e sub-baralhos?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Isso \xE9 uma alternativa para a op\xE7\xE3o de etiqueta dos Flashcards em cima.",
  INLINE_SCHEDULING_COMMENTS: "Salvar coment\xE1rios de agendamento na mesma linha que a \xFAltima linha do flashcard?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Ligar isso vai fazer com que os coment\xE1rios em HTML n\xE3o quebrem a formata\xE7\xE3o de listas.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Enterrar cartas irm\xE3s at\xE9 o pr\xF3ximo dia?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Cartas irm\xE3s s\xE3o geradas pelo texto da mesma carta ex: omiss\xE3o de palavras",
  SHOW_CARD_CONTEXT: "Mostrar contexto nas cartas?",
  SHOW_CARD_CONTEXT_DESC: "ex: T\xEDtulo > Cabe\xE7alho 1 > Subcabe\xE7alho > ... > Subcabe\xE7alho",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "Porcentagem da Altura do Flashcard",
  CARD_MODAL_SIZE_PERCENT_DESC: "Deveria estar configurado em 100% em dispositivos m\xF3veis ou se voc\xEA tem imagens muito grandes",
  RESET_DEFAULT: "Reiniciar para a pr\xE9-defini\xE7\xE3o",
  CARD_MODAL_WIDTH_PERCENT: "Porcentagem de Largura do Flashcard",
  RANDOMIZE_CARD_ORDER: "Aleatorizar a ordem das cartas durante a revis\xE3o?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "Order cards in a deck are displayed during review",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "Sequentially within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "Sequentially within a deck (All due cards first)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Randomly within a deck (All new cards first)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Randomly within a deck (All due cards first)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  REVIEW_DECK_ORDER: "Order decks are displayed during review",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "Sequentially (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Randomly (once all cards in previous deck reviewed)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Random card from random deck",
  DISABLE_CLOZE_CARDS: "Desabilitar cartas que usam omiss\xE3o de palavras?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "Converter ==marca-texto== em omiss\xF5es?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: 'Adiciona/remove o <code>${defaultPattern}</code> dos seus "Padr\xF5es de Omiss\xE3o"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "Converter **texto em negrito** em omiss\xF5es?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: 'Adiciona/remove o <code>${defaultPattern}</code> dos seus "Padr\xF5es de Omiss\xE3o"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "Converter {{chaves}} em omiss\xF5es?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: 'Adiciona/remove o <code>${defaultPattern}</code> dos seus "Padr\xF5es de Omiss\xE3o"',
  CLOZE_PATTERNS: "Padr\xF5es de Omiss\xE3o",
  CLOZE_PATTERNS_DESC: 'Entre os padr\xF5es de omiss\xE3o separados por quebras de linha. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Separador para flashcards inline",
  FIX_SEPARATORS_MANUALLY_WARNING: "Note que depois de mudar isso voc\xEA vai ter que manualmente mudar quaisquer flashcards que voc\xEA tenha.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Separador para flashcards inline reversos",
  MULTILINE_CARDS_SEPARATOR: "Separador para flashcards de m\xFAltiplas linhas",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "Separador para flashcards de m\xFAltiplas linhas reversos",
  MULTILINE_CARDS_END_MARKER: "Caracteres que denotam o fim de clozes e flashcards multilinha",
  NOTES: "Notas",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Habilitar painel de revis\xE3o de notas na inicializa\xE7\xE3o",
  TAGS_TO_REVIEW: "Etiquetas para revisar",
  TAGS_TO_REVIEW_DESC: "Insira etiquetas separadas por espa\xE7os ou quebra de linhas ex: #revisar #etiqueta2 #etiqueta3.",
  OPEN_RANDOM_NOTE: "Abrir uma nota aleat\xF3ria para revisar",
  OPEN_RANDOM_NOTE_DESC: "Quando voc\xEA desabilitar isso, as notas v\xE3o ser ordenadas por import\xE2ncia (PageRank).",
  AUTO_NEXT_NOTE: "Abrir a pr\xF3xima nota automaticamente depois de uma revis\xE3o",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Ative as op\xE7\xF5es de revis\xE3o no menu Arquivo (ex.: Revis\xE3o: F\xE1cil, OK, Dif\xEDcil)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "Se voc\xEA desativar as op\xE7\xF5es de revis\xE3o no menu Arquivo, poder\xE1 revisar suas anota\xE7\xF5es usando os comandos do plugin e, se os tiver definido, as teclas de atalho associadas.",
  MAX_N_DAYS_REVIEW_QUEUE: "N\xFAmero m\xE1ximo de dias para exibir no painel direito",
  MIN_ONE_DAY: "O n\xFAmero de dias deve ser pelo menos 1.",
  VALID_NUMBER_WARNING: "Por favor Insira um n\xFAmero v\xE1lido.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\xC1rvores de baralhos devem inicialmente ser exibidas como expandidas",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Desabilite isso para colapsar baralhos que est\xE3o um dentro do outro na mesma carta. \xDAtil se voc\xEA tem cartas que pertencem a muitos baralhos em um mesmo arquivo.",
  ALGORITHM: "Algor\xEDtmo",
  CHECK_ALGORITHM_WIKI: 'Para mais informa\xE7\xF5es, cheque a <a href="${algoUrl}">implementa\xE7\xE3o do algor\xEDtmo</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Facilidade base",
  BASE_EASE_DESC: "m\xEDnimo = 130, preferivelmente por volta de 250.",
  BASE_EASE_MIN_WARNING: "A facilidade base deve ser pelo menos 130.",
  LAPSE_INTERVAL_CHANGE: "Mudan\xE7a de intervalo quando voc\xEA revisa um(a) flashcard/nota como dif\xEDcil",
  LAPSE_INTERVAL_CHANGE_DESC: "novoIntervalo = velhoIntervalo * mudancaIntervalo / 100.",
  EASY_BONUS: "B\xF4nus de F\xE1cil",
  EASY_BONUS_DESC: "O b\xF4nus de f\xE1cil te permite mudar a difer\xEAncia entre intervalos de responder OK e F\xE1cil em um(a) flashcard/nota (m\xEDnimo = 100%).",
  EASY_BONUS_MIN_WARNING: "O b\xF4nus de f\xE1cil deve ser pelo menos 100.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Intervalo m\xE1ximo em dias",
  MAX_INTERVAL_DESC: "Te permite colocar um limite m\xE1ximo no intervalo (pr\xE9-defini\xE7\xE3o = 100 anos).",
  MAX_INTERVAL_MIN_WARNING: "O intervalo m\xE1ximo deve ser pelo menos 1 dia.",
  MAX_LINK_CONTRIB: "Contribui\xE7\xE3o M\xE1xima de Links",
  MAX_LINK_CONTRIB_DESC: "Contribui\xE7\xE3o m\xE1xima da facilidade ponderada das notas linkadas \xE0 facilidade inicial.",
  LOGGING: "Logging",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Mostrar informa\xE7\xE3o de debugging no console de desenvolvimento",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Fila de Notas para Revisar",
  CLOSE: "Fechar",
  NEW: "Novo",
  YESTERDAY: "Ontem",
  TODAY: "Hoje",
  TOMORROW: "Amanh\xE3",
  // stats-modal.tsx
  STATS_TITLE: "Estat\xEDsticas",
  MONTH: "M\xEAs",
  QUARTER: "Trimestre",
  YEAR: "Ano",
  LIFETIME: "Tempo Total",
  FORECAST: "Previs\xE3o",
  FORECAST_DESC: "O n\xFAmero de cartas a serem colocadas em dia no futuro",
  SCHEDULED: "Agendado",
  DAYS: "Dias",
  NUMBER_OF_CARDS: "N\xFAmero de cartas",
  REVIEWS_PER_DAY: "M\xE9dia: ${avg} revis\xF5es/dia",
  INTERVALS: "Intervalos",
  INTERVALS_DESC: "Atrasos at\xE9 que as revis\xF5es sejam exibidas de novo",
  COUNT: "Contagem",
  INTERVALS_SUMMARY: "Intervalo em m\xE9dia: ${avg}, Maior intervalo: ${longest}",
  EASES: "Facilidades",
  EASES_SUMMARY: "Facilidade em m\xE9dia: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Tipos de Cartas",
  CARD_TYPES_DESC: "Isso tamb\xE9m inclui cartas enterradas, caso existam",
  CARD_TYPE_NEW: "Novo",
  CARD_TYPE_YOUNG: "Jovem",
  CARD_TYPE_MATURE: "Amadurecido",
  CARD_TYPES_SUMMARY: "Total de cartas: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var pt_br_default = ptBR;

// src/lang/locale/ro.ts
var ro = {
  ...en_default,
  language: "ro",
  languageName: "Rom\xE2n\u0103"
};
var ro_default = ro;

// src/lang/locale/ru.ts
var ru = {
  ...en_default,
  language: "ru",
  languageName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
  // flashcard-modal.tsx
  DECKS: "\u041A\u043E\u043B\u043E\u0434\u044B",
  DUE_CARDS: "\u041F\u043E\u0432\u0442\u043E\u0440\u044F\u0435\u043C\u044B\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  NEW_CARDS: "\u041D\u043E\u0432\u044B\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  TOTAL_CARDS: "\u0412\u0441\u0435\u0433\u043E \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  BACK: "\u041D\u0430\u0437\u0430\u0434",
  SKIP: "\u041F\u0440\u043E\u043F\u0443\u0441\u0442\u0438\u0442\u044C",
  EDIT_CARD: "\u0420\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0443",
  RESET_CARD_PROGRESS: "\u0421\u0431\u0440\u043E\u0441\u0438\u0442\u044C \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  HARD: "\u0421\u043B\u043E\u0436\u043D\u043E",
  GOOD: "\u041D\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u043E",
  EASY: "\u041B\u0435\u0433\u043A\u043E",
  SHOW_ANSWER: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C \u043E\u0442\u0432\u0435\u0442",
  CARD_PROGRESS_RESET: "\u0421\u0431\u0440\u043E\u0441\u0438\u0442\u044C \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441 \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  SAVE: "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C",
  CANCEL: "\u041E\u0442\u043C\u0435\u043D\u0430",
  NO_INPUT: "\u041F\u0443\u0441\u0442\u043E\u0439 \u0432\u0432\u043E\u0434.",
  CURRENT_EASE_HELP_TEXT: "\u0422\u0435\u043A\u0443\u0449\u0438\u0439 \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441: ",
  CURRENT_INTERVAL_HELP_TEXT: "\u0422\u0435\u043A\u0443\u0449\u0438\u0439 \u0438\u043D\u0442\u0435\u0440\u0432\u0430\u043B: ",
  CARD_GENERATED_FROM: "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u043E \u0438\u0437: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\u041E\u0442\u043A\u0440\u044B\u0442\u044C \u0437\u0430\u043C\u0435\u0442\u043A\u0443 \u0434\u043B\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F",
  REVIEW_CARDS: "\u0418\u0437\u0443\u0447\u0430\u0442\u044C \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  REVIEW_DIFFICULTY_FILE_MENU: "\u0418\u0437\u0443\u0447\u0435\u043D\u0438\u0435: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "\u0418\u0437\u0443\u0447\u0430\u0442\u044C \u0437\u0430\u043C\u0435\u0442\u043A\u0443 \u043A\u0430\u043A ${difficulty}",
  CRAM_ALL_CARDS: "\u0417\u0443\u0431\u0440\u0438\u0442\u044C \u0432\u0441\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0432 \u044D\u0442\u043E\u0439 \u043A\u043E\u043B\u043E\u0434\u0435",
  REVIEW_ALL_CARDS: "\u0418\u0437\u0443\u0447\u0430\u0442\u044C \u0432\u0441\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0432\u043E \u0432\u0441\u0435\u0445 \u0437\u0430\u043C\u0435\u0442\u043A\u0430\u0445",
  REVIEW_CARDS_IN_NOTE: "\u0418\u0437\u0443\u0447\u0430\u0442\u044C \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0432 \u044D\u0442\u043E\u0439 \u0437\u0430\u043C\u0435\u0442\u043A\u0435",
  CRAM_CARDS_IN_NOTE: "\u0417\u0443\u0431\u0440\u0438\u0442\u044C \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0432 \u044D\u0442\u043E\u0439 \u0437\u0430\u043C\u0435\u0442\u043A\u0435",
  VIEW_STATS: "\u041F\u043E\u0441\u043C\u043E\u0442\u0440\u0435\u0442\u044C \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043A\u0443",
  OPEN_REVIEW_QUEUE_VIEW: "\u041E\u0442\u043A\u0440\u044B\u0442\u044C \u043E\u0447\u0435\u0440\u0435\u0434\u044C \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044F \u0437\u0430\u043C\u0435\u0442\u043E\u043A \u043D\u0430 \u0431\u043E\u043A\u043E\u0432\u043E\u0439 \u043F\u0430\u043D\u0435\u043B\u0438",
  STATUS_BAR: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u044C: ${dueNotesCount} \u0437\u0430\u043C\u0435\u0442\u043E\u043A, ${dueFlashcardsCount} \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  SYNC_TIME_TAKEN: "\u0421\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u044F \u0437\u0430\u043D\u044F\u043B\u0430 ${t}\u043C\u0441",
  NOTE_IN_IGNORED_FOLDER: "\u0417\u0430\u043C\u0435\u0442\u043A\u0430 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u0430 \u0432 \u0438\u0433\u043D\u043E\u0440\u0438\u0440\u0443\u0435\u043C\u0443\u044E \u043F\u0430\u043F\u043A\u0443 (\u0441\u043C. \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438).",
  PLEASE_TAG_NOTE: "\u0414\u043B\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F, \u043F\u043E\u0436\u0430\u043B\u0443\u0439\u0441\u0442\u0430, \u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u043E \u043F\u043E\u043C\u0435\u0442\u044C\u0442\u0435 \u0437\u0430\u043C\u0435\u0442\u043A\u0443 \u0442\u0435\u0433\u043E\u043C (\u0441\u043C. \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438).",
  RESPONSE_RECEIVED: "\u041E\u0442\u0432\u0435\u0442 \u043F\u043E\u043B\u0443\u0447\u0435\u043D.",
  NO_DECK_EXISTS: "\u041D\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442 \u0443\u0440\u043E\u0432\u043D\u044F ${deckName}",
  ALL_CAUGHT_UP: "\u041C\u043E\u043B\u043E\u0434\u0435\u0446! \u0422\u044B \u0441\u043F\u0440\u0430\u0432\u0438\u043B\u0441\u044F \u0438 \u0434\u043E\u0448\u0435\u043B \u0434\u043E \u043A\u043E\u043D\u0446\u0430! :D",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} \u0434\u043D\u0435\u0439",
  MONTHS_STR_IVL: "${interval} \u043C\u0435\u0441\u044F\u0446\u0435\u0432",
  YEARS_STR_IVL: "${interval} \u0433\u043E\u0434\u043E\u0432",
  DAYS_STR_IVL_MOBILE: "${interval}\u0434.",
  MONTHS_STR_IVL_MOBILE: "${interval}\u043C.",
  YEARS_STR_IVL_MOBILE: "${interval}\u0433.",
  // settings.ts
  SETTINGS_HEADER: "Spaced Repetition",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: '\u0414\u043B\u044F \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0439 \u0438\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0438\u0438 \u043F\u043E\u0441\u0435\u0442\u0438\u0442\u0435: <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "\u0418\u0433\u043D\u043E\u0440\u0438\u0440\u0443\u0435\u043C\u044B\u0435 \u043F\u0430\u043F\u043A\u0438",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "\u041A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  FLASHCARD_EASY_LABEL: '\u0422\u0435\u043A\u0441\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 "\u041B\u0435\u0433\u043A\u043E"',
  FLASHCARD_GOOD_LABEL: '\u0422\u0435\u043A\u0441\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 "\u041D\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u043E"',
  FLASHCARD_HARD_LABEL: '\u0422\u0435\u043A\u0441\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 "\u0421\u043B\u043E\u0436\u043D\u043E"',
  FLASHCARD_EASY_DESC: '\u041D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C \u044F\u0440\u043B\u044B\u043A \u0434\u043B\u044F \u043A\u043D\u043E\u043F\u043A\u0438 "\u041B\u0435\u0433\u043A\u043E"',
  FLASHCARD_GOOD_DESC: '\u041D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C \u044F\u0440\u043B\u044B\u043A \u0434\u043B\u044F \u043A\u043D\u043E\u043F\u043A\u0438 "\u041D\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u043E"',
  FLASHCARD_HARD_DESC: '\u041D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C \u044F\u0440\u043B\u044B\u043A \u0434\u043B\u044F \u043A\u043D\u043E\u043F\u043A\u0438 "\u0421\u043B\u043E\u0436\u043D\u043E"',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "\u0422\u0435\u0433\u0438 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  FLASHCARD_TAGS_DESC: "\u0423\u043A\u0430\u0436\u0438\u0442\u0435 \u0442\u0435\u0433\u0438 \u0440\u0430\u0437\u0434\u0435\u043B\u0435\u043D\u043D\u044B\u0435 Enter-\u043E\u043C \u0438\u043B\u0438 \u043F\u0440\u043E\u0431\u0435\u043B\u043E\u043C, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440: #flashcards #deck2 #deck3.",
  CONVERT_FOLDERS_TO_DECKS: "\u041A\u043E\u043D\u0432\u0435\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043F\u0430\u043F\u043A\u0438 \u0432 \u0443\u0440\u043E\u0432\u043D\u0438 \u0438 \u043F\u043E\u0434\u0443\u0440\u043E\u0432\u043D\u0438?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "\u042D\u0442\u043E \u0430\u043B\u044C\u0442\u0435\u0440\u043D\u0430\u0442\u0438\u0432\u0430 \u043E\u043F\u0438\u0441\u0430\u043D\u043D\u043E\u043C\u0443 \u0432\u044B\u0448\u0435 \u0432\u0430\u0440\u0438\u0430\u043D\u0442\u0443 \u0442\u0435\u0433\u043E\u0432 \u0444\u043B\u044D\u0448-\u043A\u0430\u0440\u0442",
  INLINE_SCHEDULING_COMMENTS: "\u0421\u043E\u0445\u0440\u0430\u043D\u044F\u0442\u044C \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u043F\u043B\u0430\u043D\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u044F \u043D\u0430 \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u0435\u0439 \u0441\u0442\u0440\u043E\u043A\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438?",
  INLINE_SCHEDULING_COMMENTS_DESC: "\u0412\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435 \u044D\u0442\u043E\u0439 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 \u0441\u0434\u0435\u043B\u0430\u0435\u0442 \u0442\u0430\u043A, \u0447\u0442\u043E HTML \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 \u043D\u0435 \u0431\u0443\u0434\u0443\u0442 \u043B\u043E\u043C\u0430\u0442\u044C \u0444\u043E\u0440\u043C\u0430\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435 \u0441\u043F\u0438\u0441\u043A\u0430.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\u041F\u0440\u044F\u0442\u0430\u0442\u044C \u0440\u043E\u0434\u0441\u0442\u0432\u0435\u043D\u043D\u044B\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0434\u043E \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u0434\u043D\u044F?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "\u0420\u043E\u0434\u0441\u0442\u0432\u0435\u043D\u043D\u044B\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 - \u0442\u0435, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u043E\u0431\u0440\u0430\u0437\u043E\u0432\u0430\u043D\u044B \u0438\u0437 \u043E\u0434\u043D\u043E\u0433\u043E \u0442\u0435\u043A\u0441\u0442\u0430, \u043F\u0440\u0438\u043C\u0435\u0440: \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0441 \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0430\u043C\u0438 ([...])",
  SHOW_CARD_CONTEXT: "\u041F\u043E\u043A\u0430\u0437\u044B\u0432\u0430\u0442\u044C \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442 (\u0443\u0440\u043E\u0432\u0435\u043D\u044C) \u0432 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0430\u0445 (\u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044F)?",
  SHOW_CARD_CONTEXT_DESC: "\u043F\u0440\u0438\u043C\u0435\u0440: Title > Heading 1 > Subheading > ... > Subheading",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "\u0412\u044B\u0441\u043E\u0442\u0430 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0432 \u043F\u0440\u043E\u0446\u0435\u043D\u0442\u0430\u0445",
  CARD_MODAL_SIZE_PERCENT_DESC: "\u0415\u0441\u043B\u0438 \u043F\u043E\u043B\u044C\u0437\u0443\u0435\u0442\u0435\u0441\u044C \u043C\u043E\u0431\u0438\u043B\u044C\u043D\u044B\u043C \u0442\u0435\u043B\u0435\u0444\u043E\u043D\u043E\u043C, \u0432\u044B\u0441\u0442\u0430\u0432\u044C\u0442\u0435 100%. \u0418\u043D\u0430\u0447\u0435 \u0443 \u0432\u0430\u0441 \u0431\u0443\u0434\u0443\u0442 \u043E\u0433\u0440\u043E\u043C\u043D\u044B\u0435 \u0438\u0437\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u044F",
  RESET_DEFAULT: "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 \u043F\u043E-\u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E",
  CARD_MODAL_WIDTH_PERCENT: "\u0428\u0438\u0440\u0438\u043D\u0430 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438 \u0432 \u043F\u0440\u043E\u0446\u0435\u043D\u0442\u0430\u0445",
  RANDOMIZE_CARD_ORDER: "\u0421\u043B\u0443\u0447\u0430\u0439\u043D\u044B\u0439 \u043F\u043E\u0440\u044F\u0434\u043E\u043A \u043A\u0430\u0440\u0442 \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "\u041F\u043E\u0440\u044F\u0434\u043E\u043A \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u044F \u043A\u0430\u0440\u0442 \u043A\u043E\u043B\u043E\u0434\u044B \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "\u041F\u043E\u0441\u043B\u0435\u0434\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043B\u043E\u0434\u044B (\u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u0441\u0435 \u043D\u043E\u0432\u044B\u0435 \u043A\u0430\u0440\u0442\u044B)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "\u041F\u043E\u0441\u043B\u0435\u0434\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043B\u043E\u0434\u044B (\u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u0441\u0435 \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u0435\u043C\u044B\u0435 \u043A\u0430\u0440\u0442\u044B)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "\u0421\u043B\u0443\u0447\u0430\u0439\u043D\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043B\u043E\u0434\u044B (\u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u0441\u0435 \u043D\u043E\u0432\u044B\u0435 \u043A\u0430\u0440\u0442\u044B)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "\u0421\u043B\u0443\u0447\u0430\u0439\u043D\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043B\u043E\u0434\u044B (\u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u0441\u0435 \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u0435\u043C\u044B\u0435 \u043A\u0430\u0440\u0442\u044B)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "\u0421\u043B\u0443\u0447\u0430\u0439\u043D\u0430\u044F \u043A\u0430\u0440\u0442\u0430 \u0438\u0437 \u0441\u043B\u0443\u0447\u0430\u0439\u043D\u043E\u0439 \u043A\u043E\u043B\u043E\u0434\u044B",
  REVIEW_DECK_ORDER: "\u041F\u043E\u0440\u044F\u0434\u043E\u043A \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u044F \u043A\u043E\u043B\u043E\u0434 \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "\u041F\u043E\u0441\u043B\u0435\u0434\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u043D\u043E  (\u043F\u043E\u0441\u043B\u0435 \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F \u0432\u0441\u0435\u0445 \u043A\u0430\u0440\u0442 \u0438\u0437 \u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0435\u0439 \u043A\u043E\u043B\u043E\u0434\u044B)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "\u0421\u043B\u0443\u0447\u0430\u0439\u043D\u043E (\u043F\u043E\u0441\u043B\u0435 \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F \u0432\u0441\u0435\u0445 \u043A\u0430\u0440\u0442 \u0438\u0437 \u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0435\u0439 \u043A\u043E\u043B\u043E\u0434\u044B)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "\u0421\u043B\u0443\u0447\u0430\u0439\u043D\u0430\u044F \u043A\u0430\u0440\u0442\u0430 \u0438\u0437 \u0441\u043B\u0443\u0447\u0430\u0439\u043D\u043E\u0439 \u043A\u043E\u043B\u043E\u0434\u044B",
  DISABLE_CLOZE_CARDS: "\u0412\u044B\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u043A\u0430\u0440\u0442\u044B \u0441 \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0430\u043C\u0438 (\u043F\u0440\u0438\u043C\u0435\u0440: [...])?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "\u041A\u043E\u043D\u0432\u0435\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C ==\u0432\u044B\u0434\u0435\u043B\u0435\u043D\u043D\u044B\u0439 \u0442\u0435\u043A\u0441\u0442== \u0432 \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0438 (\u043F\u0440\u0438\u043C\u0435\u0440: [...])?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: '\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C/\u0443\u0434\u0430\u043B\u0438\u0442\u044C <code>${defaultPattern}</code> \u0432 \u0432\u0430\u0448\u0438 "\u0428\u0430\u0431\u043B\u043E\u043D\u044B \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u043E\u0432"',
  CONVERT_BOLD_TEXT_TO_CLOZES: "\u041A\u043E\u043D\u0432\u0435\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C **\u0436\u0438\u0440\u043D\u044B\u0439 \u0442\u0435\u043A\u0441\u0442** \u0432 \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0438 (\u043F\u0440\u0438\u043C\u0435\u0440: [...])?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: '\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C/\u0443\u0434\u0430\u043B\u0438\u0442\u044C <code>${defaultPattern}</code> \u0432 \u0432\u0430\u0448\u0438 "\u0428\u0430\u0431\u043B\u043E\u043D\u044B \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u043E\u0432"',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "\u041A\u043E\u043D\u0432\u0435\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C {{\u0444\u0438\u0433\u0443\u0440\u043D\u044B\u0435 \u0441\u043A\u043E\u0431\u043A\u0438}} \u0432 \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0438 (\u043F\u0440\u0438\u043C\u0435\u0440: [...])?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: '\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C/\u0443\u0434\u0430\u043B\u0438\u0442\u044C <code>${defaultPattern}</code> \u0432 \u0432\u0430\u0448\u0438 "\u0428\u0430\u0431\u043B\u043E\u043D\u044B \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u043E\u0432"',
  CLOZE_PATTERNS: "\u0428\u0430\u0431\u043B\u043E\u043D\u044B \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u043E\u0432",
  CLOZE_PATTERNS_DESC: '\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0448\u0430\u0431\u043B\u043E\u043D\u044B \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u043E\u0432, \u0440\u0430\u0437\u0434\u0435\u043B\u0435\u043D\u043D\u044B\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u0430\u043C\u0438 \u0441\u0442\u0440\u043E\u043A. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "\u0420\u0430\u0437\u0434\u0435\u043B\u0438\u0442\u0435\u043B\u044C \u0434\u043B\u044F \u0432\u043D\u0443\u0442\u0440\u0438\u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0445 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  FIX_SEPARATORS_MANUALLY_WARNING: "\u0412\u043D\u0438\u043C\u0430\u043D\u0438\u0435! \u041F\u043E\u0441\u043B\u0435 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F \u044D\u0442\u043E\u0433\u043E \u0432\u0430\u043C \u043F\u0440\u0438\u0434\u0451\u0442\u0441\u044F \u0432\u0440\u0443\u0447\u043D\u0443\u044E \u0440\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0443\u0436\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438",
  INLINE_REVERSED_CARDS_SEPARATOR: "\u0420\u0430\u0437\u0434\u0435\u043B\u0438\u0442\u0435\u043B\u044C \u0434\u043B\u044F \u043E\u0431\u0440\u0430\u0442\u043D\u044B\u0445 \u0432\u043D\u0443\u0442\u0440\u0438\u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0445 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  MULTILINE_CARDS_SEPARATOR: "\u0420\u0430\u0437\u0434\u0435\u043B\u0438\u0442\u0435\u043B\u044C \u0434\u043B\u044F \u043C\u043D\u043E\u0433\u043E\u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0445 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\u0420\u0430\u0437\u0434\u0435\u043B\u0438\u0442\u0435\u043B\u044C \u0434\u043B\u044F \u043E\u0431\u0440\u0430\u0442\u043D\u044B\u0445 \u043C\u043D\u043E\u0433\u043E\u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0445 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  MULTILINE_CARDS_END_MARKER: "\u0421\u0438\u043C\u0432\u043E\u043B\u044B, \u043E\u0431\u043E\u0437\u043D\u0430\u0447\u0430\u044E\u0449\u0438\u0435 \u043A\u043E\u043D\u0435\u0446 \u043A\u043B\u043E\u0437\u043E\u0432 \u0438 \u043C\u043D\u043E\u0433\u043E\u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0445 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  NOTES: "\u0417\u0430\u043C\u0435\u0442\u043A\u0438",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "\u0412\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u043F\u0430\u043D\u0435\u043B\u044C \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A \u043F\u0440\u0438 \u0437\u0430\u043F\u0443\u0441\u043A\u0435 \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u044B",
  TAGS_TO_REVIEW: "\u0422\u0435\u0433\u0438 \u0434\u043B\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F",
  TAGS_TO_REVIEW_DESC: "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0442\u0435\u0433\u0438, \u0440\u0430\u0437\u0434\u0435\u043B\u0435\u043D\u043D\u044B\u0435 Enter-\u0430\u043C\u0438 \u0438\u043B\u0438 \u043F\u0440\u043E\u0431\u0435\u043B\u0430\u043C\u0438, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440: #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "\u041E\u0442\u043A\u0440\u044B\u0442\u044C \u0441\u043B\u0443\u0447\u0430\u0439\u043D\u0443\u044E \u0437\u0430\u043C\u0435\u0442\u043A\u0443 \u0434\u043B\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F",
  OPEN_RANDOM_NOTE_DESC: "\u0415\u0441\u043B\u0438 \u0432\u044B\u043A\u043B\u044E\u0447\u0438\u0442\u044C, \u0442\u043E \u0437\u0430\u043C\u0435\u0442\u043A\u0438 \u0431\u0443\u0434\u0443\u0442 \u043E\u0442\u0441\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u044B \u043F\u043E \u0432\u0430\u0436\u043D\u043E\u0441\u0442\u0438 (PageRank).",
  AUTO_NEXT_NOTE: "\u041F\u043E\u0441\u043B\u0435 \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u043E\u0442\u043A\u0440\u044B\u0432\u0430\u0442\u044C \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0443\u044E \u0437\u0430\u043C\u0435\u0442\u043A\u0443",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\u0412\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u044B \u043E\u0431\u0437\u043E\u0440\u0430 \u0432 \u043C\u0435\u043D\u044E \u0424\u0430\u0439\u043B (\u0442.\u0435.: \u0418\u0437\u0443\u0447\u0435\u043D\u0438\u0435: \u041B\u0435\u0433\u043A\u043E, \u041D\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u043E, \u0421\u043B\u043E\u0436\u043D\u043E)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\u0415\u0441\u043B\u0438 \u0432\u044B \u043E\u0442\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u044B \u043E\u0431\u0437\u043E\u0440\u0430 \u0432 \u043C\u0435\u043D\u044E \u0424\u0430\u0439\u043B, \u0432\u044B \u0441\u043C\u043E\u0436\u0435\u0442\u0435 \u043F\u0440\u043E\u0441\u043C\u0430\u0442\u0440\u0438\u0432\u0430\u0442\u044C \u0441\u0432\u043E\u0438 \u0437\u0430\u043C\u0435\u0442\u043A\u0438 \u0441 \u043F\u043E\u043C\u043E\u0449\u044C\u044E \u043A\u043E\u043C\u0430\u043D\u0434 \u043F\u043B\u0430\u0433\u0438\u043D\u0430 \u0438, \u0435\u0441\u043B\u0438 \u0432\u044B \u0438\u0445 \u0437\u0430\u0434\u0430\u043B\u0438, \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u0445 \u0433\u043E\u0440\u044F\u0447\u0438\u0445 \u043A\u043B\u0430\u0432\u0438\u0448.",
  MAX_N_DAYS_REVIEW_QUEUE: "\u041D\u0430\u0438\u0431\u043E\u043B\u044C\u0448\u0435\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0434\u043D\u0435\u0439 \u0434\u043B\u044F \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u0435 \u043D\u0430 \u043F\u0430\u043D\u0435\u043B\u0438 \u0441\u043F\u0440\u0430\u0432\u0430",
  MIN_ONE_DAY: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0434\u043D\u0435\u0439 \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 1.",
  VALID_NUMBER_WARNING: "\u041F\u043E\u0436\u0430\u043B\u0443\u0439\u0441\u0442\u0430, \u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043F\u043E\u0434\u0445\u043E\u0434\u044F\u0449\u0435\u0435 \u0447\u0438\u0441\u043B\u043E.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\u0414\u0435\u0440\u0435\u0432\u044C\u044F \u043A\u043E\u043B\u043E\u0434 \u0434\u043E\u043B\u0436\u043D\u044B \u0438\u0437\u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0430\u0442\u044C\u0441\u044F \u043A\u0430\u043A \u0440\u0430\u0437\u0432\u0435\u0440\u043D\u0443\u0442\u044B\u0435",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "\u041E\u0442\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u044D\u0442\u043E\u0442 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440, \u0447\u0442\u043E\u0431\u044B \u0441\u0432\u0435\u0440\u043D\u0443\u0442\u044C \u0432\u043B\u043E\u0436\u0435\u043D\u043D\u044B\u0435 \u043A\u043E\u043B\u043E\u0434\u044B \u043D\u0430 \u043E\u0434\u043D\u043E\u0439 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435. \u041F\u043E\u043B\u0435\u0437\u043D\u043E, \u0435\u0441\u043B\u0438 \u0443 \u0432\u0430\u0441 \u0435\u0441\u0442\u044C \u043A\u0430\u0440\u0442\u044B, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u043F\u0440\u0438\u043D\u0430\u0434\u043B\u0435\u0436\u0430\u0442 \u043C\u043D\u043E\u0433\u0438\u043C \u043A\u043E\u043B\u043E\u0434\u0430\u043C \u0432 \u043E\u0434\u043D\u043E\u043C \u0444\u0430\u0439\u043B\u0435.",
  ALGORITHM: "\u0410\u043B\u0433\u043E\u0440\u0438\u0442\u043C",
  CHECK_ALGORITHM_WIKI: '\u0417\u0430 \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0439 \u0438\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0438\u0435\u0439 \u043E\u0431\u0440\u0430\u0449\u0430\u0439\u0442\u0435\u0441\u044C \u043A <a href="${algoUrl}">\u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u0430</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "\u0411\u0430\u0437\u043E\u0432\u0430\u044F \u041B\u0451\u0433\u043A\u043E\u0441\u0442\u044C",
  BASE_EASE_DESC: "\u043C\u0438\u043D\u0438\u043C\u0443\u043C = 130, \u043F\u0440\u0435\u0434\u043F\u043E\u0447\u0442\u0438\u0442\u0435\u043B\u044C\u043D\u043E \u043E\u043A\u043E\u043B\u043E 250.",
  BASE_EASE_MIN_WARNING: "\u041B\u0451\u0433\u043A\u043E\u0441\u0442\u044C \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u043C\u0438\u043D\u0438\u043C\u0443\u043C 130.",
  LAPSE_INTERVAL_CHANGE: '\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0435 \u0438\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0430 \u043F\u0440\u0438 \u0432\u044B\u0431\u043E\u0440\u0435 "\u0421\u043B\u043E\u0436\u043D\u043E" \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438/\u0437\u0430\u043C\u0435\u0442\u043A\u0438',
  LAPSE_INTERVAL_CHANGE_DESC: "\u043D\u043E\u0432\u044B\u0439\u041F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043E\u043A = \u0441\u0442\u0430\u0440\u044B\u0439\u041F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043E\u043A * \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0435\u041F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043A\u0430 / 100.",
  EASY_BONUS: "\u041B\u0435\u0433\u043A\u043E: \u0431\u043E\u043D\u0443\u0441",
  EASY_BONUS_DESC: "\u0411\u043E\u043D\u0443\u0441 \u0437\u0430 \u041B\u0435\u0433\u043A\u043E \u043F\u043E\u0437\u0432\u043E\u043B\u044F\u0435\u0442 \u0432\u0430\u043C \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u044C \u0440\u0430\u0437\u043D\u0438\u0446\u0443 \u0432 \u043F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043A\u0430\u0445 \u043C\u0435\u0436\u0434\u0443 \u043E\u0442\u0432\u0435\u0442\u0430\u043C\u0438 \u0425\u043E\u0440\u043E\u0448\u043E \u0438 \u041B\u0435\u0433\u043A\u043E \u043D\u0430 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0435/\u0437\u0430\u043C\u0435\u0442\u043A\u0435 (\u043C\u0438\u043D. = 100%).",
  EASY_BONUS_MIN_WARNING: '\u0411\u043E\u043D\u0443\u0441 \u0437\u0430 "\u041B\u0435\u0433\u043A\u043E" \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 100.',
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u044B\u0439 \u0438\u043D\u0442\u0435\u0440\u0432\u0430\u043B \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044F \u0432 \u0434\u043D\u044F\u0445",
  MAX_INTERVAL_DESC: "\u041F\u043E\u0437\u0432\u043E\u043B\u044F\u0435\u0442 \u0432\u0430\u043C \u0443\u0441\u0442\u0430\u043D\u0430\u0432\u043B\u0438\u0432\u0430\u0442\u044C \u0432\u0435\u0440\u0445\u043D\u044E\u044E \u0433\u0440\u0430\u043D\u0438\u0446\u0443 \u043D\u0430 \u0438\u043D\u0442\u0435\u0440\u0432\u0430\u043B \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044F (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E = 100 \u043B\u0435\u0442).",
  MAX_INTERVAL_MIN_WARNING: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u044B\u0439 \u0438\u043D\u0442\u0435\u0440\u0432\u0430\u043B \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 1.",
  MAX_LINK_CONTRIB: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u044B\u0439 \u0432\u043A\u043B\u0430\u0434 \u0441\u0432\u044F\u0437\u0438 (\u0441\u0441\u044B\u043B\u043A\u0438)",
  MAX_LINK_CONTRIB_DESC: '\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u044B\u0439 \u0432\u043A\u043B\u0430\u0434 \u0441\u0440\u0435\u0434\u043D\u0435\u0433\u043E \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F "\u041B\u0451\u0433\u043A\u043E\u0441\u0442\u0438" \u0441\u0432\u044F\u0437\u0430\u043D\u043D\u044B\u0445 \u0437\u0430\u043C\u0435\u0442\u043E\u043A \u0432 \u043D\u0430\u0447\u0430\u043B\u044C\u043D\u0443\u044E "\u041B\u0451\u0433\u043A\u043E\u0441\u0442\u044C".',
  LOGGING: "\u0416\u0443\u0440\u043D\u0430\u043B\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\u041E\u0442\u043E\u0431\u0440\u0430\u0436\u0430\u0442\u044C \u043E\u0442\u043B\u0430\u0434\u043E\u0447\u043D\u0443\u044E \u0438\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0438\u044E \u0432 \u043A\u043E\u043D\u0441\u043E\u043B\u0438 \u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u0447\u0438\u043A\u0430",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\u041E\u0447\u0435\u0440\u0435\u0434\u044C \u0437\u0430\u043C\u0435\u0442\u043E\u043A \u043D\u0430 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u0435",
  CLOSE: "\u0417\u0430\u043A\u0440\u044B\u0442\u044C",
  NEW: "\u041D\u043E\u0432\u044B\u0435",
  YESTERDAY: "\u0412\u0447\u0435\u0440\u0430\u0448\u043D\u0438\u0435",
  TODAY: "\u0421\u0435\u0433\u043E\u0434\u043D\u044F\u0448\u043D\u0438\u0435",
  TOMORROW: "\u0417\u0430\u0432\u0442\u0440\u0430\u0448\u043D\u0438\u0435",
  // stats-modal.tsx
  STATS_TITLE: "\u0421\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043A\u0430",
  MONTH: "\u041C\u0435\u0441\u044F\u0446",
  QUARTER: "\u041A\u0432\u0430\u0440\u0442\u0430\u043B",
  YEAR: "\u0413\u043E\u0434",
  LIFETIME: "\u0412\u0441\u0451 \u0432\u0440\u0435\u043C\u044F",
  FORECAST: "\u041F\u0440\u043E\u0433\u043D\u043E\u0437",
  FORECAST_DESC: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A \u043F\u0440\u0435\u0434\u0441\u0442\u043E\u044F\u0449\u0438\u0445 \u0434\u043B\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044F",
  SCHEDULED: "\u0417\u0430\u043F\u043B\u0430\u043D\u0438\u0440\u043E\u0432\u0430\u043D\u043E",
  DAYS: "\u0414\u043D\u0438",
  NUMBER_OF_CARDS: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  REVIEWS_PER_DAY: "\u0421\u0440\u0435\u0434\u043D\u0435\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E: ${avg} \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u0439 \u0432 \u0434\u0435\u043D\u044C",
  INTERVALS: "\u0418\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u044B",
  INTERVALS_DESC: "\u041F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043A\u0438 \u0432\u0440\u0435\u043C\u0435\u043D\u0438 \u0434\u043E \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043F\u043E\u043A\u0430\u0437\u0430 \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044F",
  COUNT: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E",
  INTERVALS_SUMMARY: "\u0421\u0440\u0435\u0434\u043D\u0438\u0439 \u043F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043E\u043A: ${avg}, \u0421\u0430\u043C\u044B\u0439 \u0434\u043B\u0438\u043D\u043D\u044B\u0439 \u043F\u0440\u043E\u043C\u0435\u0436\u0443\u0442\u043E\u043A: ${longest}",
  EASES: "\u041F\u0440\u043E\u0433\u0440\u0435\u0441\u0441 \u0438\u0437\u0443\u0447\u0435\u043D\u0438\u044F",
  EASES_SUMMARY: "\u0421\u0440\u0435\u0434\u043D\u0435\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441\u0430: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "\u0422\u0438\u043F\u044B \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A",
  CARD_TYPES_DESC: "\u0412\u043A\u043B\u044E\u0447\u0430\u044F \u0441\u043F\u0440\u044F\u0442\u0430\u043D\u043D\u044B\u0435 \u043A\u0430\u0440\u0442\u043E\u0447\u043A\u0438, \u0435\u0441\u043B\u0438 \u0442\u0430\u043A\u0438\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u044E\u0442.",
  CARD_TYPE_NEW: "\u041D\u043E\u0432\u044B\u0445",
  CARD_TYPE_YOUNG: "\u041F\u043E\u0432\u0442\u043E\u0440\u044F\u0435\u043C\u044B\u0445",
  CARD_TYPE_MATURE: "\u0418\u0437\u0443\u0447\u0435\u043D\u043D\u044B\u0445",
  CARD_TYPES_SUMMARY: "\u0412\u0441\u0435\u0433\u043E \u043A\u0430\u0440\u0442\u043E\u0447\u0435\u043A: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var ru_default = ru;

// src/lang/locale/sw.ts
var sw = {
  ...en_default,
  language: "sw",
  languageName: "Kiswahili"
};
var sw_default = sw;

// src/lang/locale/ta.ts
var ta = {
  ...en_default,
  language: "ta",
  languageName: "\u0BA4\u0BAE\u0BBF\u0BB4\u0BCD"
};
var ta_default = ta;

// src/lang/locale/te.ts
var te = {
  ...en_default,
  language: "te",
  languageName: "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41"
};
var te_default = te;

// src/lang/locale/th.ts
var th = {
  ...en_default,
  language: "th",
  languageName: "\u0E20\u0E32\u0E29\u0E32\u0E44\u0E17\u0E22"
};
var th_default = th;

// src/lang/locale/tr.ts
var tr = {
  ...en_default,
  language: "tr",
  languageName: "T\xFCrk\xE7e",
  // flashcard-modal.tsx
  DECKS: "Desteler",
  DUE_CARDS: "G\xFCncel Kartlar",
  NEW_CARDS: "Yeni Kartlar",
  TOTAL_CARDS: "Toplam Kartlar",
  BACK: "Geri",
  SKIP: "Atla",
  EDIT_CARD: "Kart\u0131 D\xFCzenle",
  RESET_CARD_PROGRESS: "Kart\u0131n ilerlemesini s\u0131f\u0131rla",
  HARD: "Zor",
  GOOD: "Orta",
  EASY: "Kolay",
  SHOW_ANSWER: "Cevab\u0131 G\xF6ster",
  CARD_PROGRESS_RESET: "Kart\u0131n ilerlemesi s\u0131f\u0131rland\u0131.",
  SAVE: "Kaydet",
  CANCEL: "\u0130ptal",
  NO_INPUT: "Girdi sa\u011Flanmad\u0131.",
  CURRENT_EASE_HELP_TEXT: "Mevcut Kolayl\u0131k: ",
  CURRENT_INTERVAL_HELP_TEXT: "Mevcut Aral\u0131k: ",
  CARD_GENERATED_FROM: "${notePath} kayna\u011F\u0131ndan olu\u015Fturuldu.",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "G\xF6zden ge\xE7irmek i\xE7in bir not a\xE7",
  REVIEW_CARDS: "Flash kartlar\u0131 g\xF6zden ge\xE7ir",
  REVIEW_DIFFICULTY_FILE_MENU: "G\xF6zden Ge\xE7ir: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "Notu ${difficulty} derecesiyle g\xF6zden ge\xE7ir",
  CRAM_ALL_CARDS: "T\xFCm destelerden yo\u011Fun tekrar yap",
  REVIEW_ALL_CARDS: "T\xFCm notlardaki flash kartlar\u0131 g\xF6zden ge\xE7ir",
  REVIEW_CARDS_IN_NOTE: "Bu nottaki flash kartlar\u0131 g\xF6zden ge\xE7ir",
  CRAM_CARDS_IN_NOTE: "Bu nottaki flash kartlar\u0131 yo\u011Fun tekrar yap",
  VIEW_STATS: "\u0130statistikleri g\xF6r\xFCnt\xFCle",
  OPEN_REVIEW_QUEUE_VIEW: "Kenar \xE7ubu\u011Funda Not G\xF6zden Ge\xE7irme S\u0131ras\u0131n\u0131 a\xE7",
  STATUS_BAR: "G\xF6zden Ge\xE7ir: ${dueNotesCount} not, ${dueFlashcardsCount} kart g\xFCncel",
  SYNC_TIME_TAKEN: "Senkronizasyon ${t}ms s\xFCrd\xFC",
  NOTE_IN_IGNORED_FOLDER: "Not, d\u0131\u015Flanan klas\xF6rde kay\u0131tl\u0131 (ayarlar\u0131 kontrol edin).",
  PLEASE_TAG_NOTE: "L\xFCtfen g\xF6zden ge\xE7irmek i\xE7in notu uygun \u015Fekilde etiketleyin (ayarlar i\xE7inde).",
  RESPONSE_RECEIVED: "Yan\u0131t al\u0131nd\u0131.",
  NO_DECK_EXISTS: "${deckName} ad\u0131nda bir deste yok",
  ALL_CAUGHT_UP: "\u{1F3C6} \u015Eampiyon gibi bitirdin! \u{1F604}",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} g\xFCn",
  MONTHS_STR_IVL: "${interval} ay",
  YEARS_STR_IVL: "${interval} y\u0131l",
  DAYS_STR_IVL_MOBILE: "${interval}g",
  MONTHS_STR_IVL_MOBILE: "${interval}a",
  YEARS_STR_IVL_MOBILE: "${interval}y",
  // settings.ts
  SETTINGS_HEADER: "Aral\u0131kl\u0131 Tekrar",
  GROUP_TAGS_FOLDERS: "Etiketler ve Klas\xF6rler",
  GROUP_FLASHCARD_REVIEW: "Flash Kartlar\u0131 G\xF6zden Ge\xE7irme",
  GROUP_FLASHCARD_SEPARATORS: "Flash Kart Ay\u0131r\u0131c\u0131lar\u0131",
  GROUP_DATA_STORAGE: "Planlama Verilerinin Saklanmas\u0131",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flash Kartlar ve Notlar",
  GROUP_CONTRIBUTING: "Katk\u0131da Bulunma",
  CHECK_WIKI: 'Daha fazla bilgi i\xE7in <a href="${wikiUrl}">wiki</a> sayfas\u0131na g\xF6z at\u0131n.',
  GITHUB_DISCUSSIONS: 'Soru-cevap, geri bildirim ve genel tart\u0131\u015Fmalar i\xE7in <a href="${discussionsUrl}">tart\u0131\u015Fmalar</a> b\xF6l\xFCm\xFCne g\xF6z at\u0131n.',
  GITHUB_ISSUES: 'Bir \xF6zellik iste\u011Finiz ya da hata bildiriminiz varsa <a href="${issuesUrl}">buradan</a> bildirin.',
  GITHUB_SOURCE_CODE: 'Proje kaynak koduna <a href="${githubProjectUrl}">GitHub</a> \xFCzerinden ula\u015Fabilirsiniz.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Kod katk\u0131lar\u0131</a> hakk\u0131nda bilgi al\u0131n.',
  TRANSLATION_CONTRIBUTION_INFO: 'Eklentiyi kendi dilinize \xE7evirmek hakk\u0131nda bilgi i\xE7in <a href="${translationContributionUrl}">\xE7eviri katk\u0131lar\u0131</a> sayfas\u0131n\u0131 ziyaret edin.',
  FOLDERS_TO_IGNORE: "Yoksay\u0131lan Klas\xF6rler",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "Flash Kartlar",
  FLASHCARD_EASY_LABEL: "Kolay Butonu Metni",
  FLASHCARD_GOOD_LABEL: "Orta Butonu Metni",
  FLASHCARD_HARD_LABEL: "Zor Butonu Metni",
  FLASHCARD_EASY_DESC: '"Kolay" butonunun metnini \xF6zelle\u015Ftirin',
  FLASHCARD_GOOD_DESC: '"Orta" butonunun metnini \xF6zelle\u015Ftirin',
  FLASHCARD_HARD_DESC: '"Zor" butonunun metnini \xF6zelle\u015Ftirin',
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "Flash Kart Etiketleri",
  FLASHCARD_TAGS_DESC: "Etiketleri bo\u015Fluklar veya yeni sat\u0131rlarla ay\u0131rarak girin, \xF6rne\u011Fin: #flashcards #deck2 #deck3.",
  CONVERT_FOLDERS_TO_DECKS: "Klas\xF6rleri destelere ve alt destelere d\xF6n\xFC\u015Ft\xFCr?",
  CONVERT_FOLDERS_TO_DECKS_DESC: "Bu, yukar\u0131daki Flash Kart etiketleri se\xE7ene\u011Fine bir alternatiftir.",
  INLINE_SCHEDULING_COMMENTS: "Planlama yorumunu flash kart\u0131n son sat\u0131r\u0131yla ayn\u0131 sat\u0131ra kaydet?",
  INLINE_SCHEDULING_COMMENTS_DESC: "Bunu a\xE7mak, HTML yorumlar\u0131n\u0131n liste bi\xE7imlendirmesini bozmamas\u0131n\u0131 sa\u011Flar.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "Karde\u015F kartlar\u0131 bir sonraki g\xFCne kadar gizle?",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "Karde\u015F kartlar, ayn\u0131 kart metninden \xFCretilen kartlard\u0131r (\xF6rne\u011Fin gizlemeler).",
  SHOW_CARD_CONTEXT: "Kartlarda ba\u011Flam\u0131 g\xF6ster?",
  SHOW_CARD_CONTEXT_DESC: "\xD6rne\u011Fin: Ba\u015Fl\u0131k > Ba\u015Fl\u0131k 1 > Alt Ba\u015Fl\u0131k > ... > Alt Ba\u015Fl\u0131k",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "Flash Kart Y\xFCkseklik Y\xFCzdesi",
  CARD_MODAL_SIZE_PERCENT_DESC: "Mobilde veya \xE7ok b\xFCy\xFCk resimleriniz varsa %100 olarak ayarlay\u0131n.",
  RESET_DEFAULT: "Varsay\u0131lana s\u0131f\u0131rla",
  CARD_MODAL_WIDTH_PERCENT: "Flash Kart Geni\u015Flik Y\xFCzdesi",
  RANDOMIZE_CARD_ORDER: "\u0130nceleme s\u0131ras\u0131nda kart s\u0131ras\u0131n\u0131 rastgele yap?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "\u0130nceleme s\u0131ras\u0131nda bir destede kartlar\u0131n g\xF6r\xFCnt\xFClenme s\u0131ras\u0131",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "S\u0131ral\u0131 olarak (\xF6nce t\xFCm yeni kartlar)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "S\u0131ral\u0131 olarak (\xF6nce t\xFCm g\xFCncel kartlar)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "Rastgele olarak (\xF6nce t\xFCm yeni kartlar)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "Rastgele olarak (\xF6nce t\xFCm g\xFCncel kartlar)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "Rastgele desteden rastgele kart",
  REVIEW_DECK_ORDER: "\u0130nceleme s\u0131ras\u0131nda destelerin g\xF6r\xFCnt\xFClenme s\u0131ras\u0131",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "S\u0131ral\u0131 olarak (\xD6nceki destedeki t\xFCm kartlar g\xF6zden ge\xE7irildikten sonra)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "Rastgele olarak (\xD6nceki destedeki t\xFCm kartlar g\xF6zden ge\xE7irildikten sonra)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "Rastgele desteden rastgele kart",
  DISABLE_CLOZE_CARDS: "Gizli kartlar\u0131 devre d\u0131\u015F\u0131 b\u0131rak?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "==Vurgulanan== metni gizli kartlara d\xF6n\xFC\u015Ft\xFCr?",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: '"Cloze Patterns"den <code>${defaultPattern</code> \xF6\u011Fesini ekleyin/kald\u0131r\u0131n',
  CONVERT_BOLD_TEXT_TO_CLOZES: "**Kal\u0131n metni** gizli kartlara d\xF6n\xFC\u015Ft\xFCr?",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: '"Cloze Patterns"den <code>${defaultPattern</code> \xF6\u011Fesini ekleyin/kald\u0131r\u0131n',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "{{K\u0131v\u0131rc\u0131k parantezleri}} gizli kartlara d\xF6n\xFC\u015Ft\xFCr?",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: '"Cloze Patterns"den <code>${defaultPattern</code> \xF6\u011Fesini ekleyin/kald\u0131r\u0131n',
  CLOZE_PATTERNS: "Cloze Patterns",
  CLOZE_PATTERNS_DESC: 'Enter cloze patterns separated by newlines. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "Sat\u0131r i\xE7i flash kartlar i\xE7in ay\u0131r\u0131c\u0131",
  FIX_SEPARATORS_MANUALLY_WARNING: "Bunu de\u011Fi\u015Ftirdikten sonra mevcut flash kartlar\u0131n\u0131z\u0131 manuel olarak d\xFCzenlemeniz gerekti\u011Fini unutmay\u0131n.",
  INLINE_REVERSED_CARDS_SEPARATOR: "Sat\u0131r i\xE7i ters flash kartlar i\xE7in ay\u0131r\u0131c\u0131",
  MULTILINE_CARDS_SEPARATOR: "\xC7ok sat\u0131rl\u0131 flash kartlar i\xE7in ay\u0131r\u0131c\u0131",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\xC7ok sat\u0131rl\u0131 ters flash kartlar i\xE7in ay\u0131r\u0131c\u0131",
  MULTILINE_CARDS_END_MARKER: "Gizli kartlar ve \xE7ok sat\u0131rl\u0131 flash kartlar\u0131n sonunu belirten karakterler",
  NOTES: "Notlar",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "Ba\u015Flang\u0131\xE7ta not inceleme panelini etkinle\u015Ftir",
  TAGS_TO_REVIEW: "G\xF6zden ge\xE7irilecek etiketler",
  TAGS_TO_REVIEW_DESC: "Etiketleri bo\u015Fluklar veya yeni sat\u0131rlarla ay\u0131rarak girin, \xF6rne\u011Fin: #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "G\xF6zden ge\xE7irmek i\xE7in rastgele bir not a\xE7",
  OPEN_RANDOM_NOTE_DESC: "Bunu kapatt\u0131\u011F\u0131n\u0131zda, notlar \xF6nem s\u0131ras\u0131na g\xF6re s\u0131ralan\u0131r (PageRank).",
  AUTO_NEXT_NOTE: "Bir incelemeden sonra otomatik olarak bir sonraki notu a\xE7",
  MAX_N_DAYS_REVIEW_QUEUE: "Sa\u011F panelde g\xF6sterilecek maksimum g\xFCn say\u0131s\u0131",
  MIN_ONE_DAY: "G\xFCn say\u0131s\u0131 en az 1 olmal\u0131d\u0131r.",
  VALID_NUMBER_WARNING: "L\xFCtfen ge\xE7erli bir say\u0131 girin.",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "Enable the review options in the file menu (e.g. Review: Easy, Good, Hard)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "If you disable the review options in the file menu, you can review your notes using the plugin commands and, if you defined them, the associated command hotkeys.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "Deste a\u011Fa\xE7lar\u0131 ba\u015Flang\u0131\xE7ta geni\u015Fletilmi\u015F olarak g\xF6sterilmeli mi",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "Bunu kapat\u0131n, ayn\u0131 dosyada bir\xE7ok desteye ait kartlar\u0131n\u0131z varsa i\xE7 i\xE7e desteleri daraltmak i\xE7in kullan\u0131\u015Fl\u0131d\u0131r.",
  ALGORITHM: "Algoritma",
  CHECK_ALGORITHM_WIKI: 'Daha fazla bilgi i\xE7in <a href="${algoUrl}">algoritma uygulamas\u0131na</a> g\xF6z at\u0131n.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "Temel kolayl\u0131k",
  BASE_EASE_DESC: "minimum = 130, tercihen yakla\u015F\u0131k 250.",
  BASE_EASE_MIN_WARNING: "Temel kolayl\u0131k en az 130 olmal\u0131d\u0131r.",
  LAPSE_INTERVAL_CHANGE: "Bir flash kart\u0131/notu zor olarak inceledi\u011Finizde aral\u0131k de\u011Fi\u015Fikli\u011Fi",
  LAPSE_INTERVAL_CHANGE_DESC: "yeniAral\u0131k = eskiAral\u0131k * aral\u0131kDe\u011Fi\u015Fikli\u011Fi / 100.",
  EASY_BONUS: "Kolayl\u0131k Bonusu",
  EASY_BONUS_DESC: "Kolayl\u0131k bonusu, bir flash kart\u0131/notu \u0130yi ve Kolay yan\u0131tlad\u0131\u011F\u0131n\u0131zda aral\u0131klardaki fark\u0131 ayarlaman\u0131za olanak tan\u0131r (minimum = %100).",
  EASY_BONUS_MIN_WARNING: "Kolayl\u0131k bonusu en az %100 olmal\u0131d\u0131r.",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "Maksimum aral\u0131k (g\xFCn)",
  MAX_INTERVAL_DESC: "Aral\u0131\u011Fa bir \xFCst s\u0131n\u0131r koyman\u0131za olanak tan\u0131r (varsay\u0131lan = 100 y\u0131l).",
  MAX_INTERVAL_MIN_WARNING: "Maksimum aral\u0131k en az 1 g\xFCn olmal\u0131d\u0131r.",
  MAX_LINK_CONTRIB: "Maksimum ba\u011Flant\u0131 katk\u0131s\u0131",
  MAX_LINK_CONTRIB_DESC: "Ba\u011Flant\u0131l\u0131 notlar\u0131n a\u011F\u0131rl\u0131kl\u0131 kolayl\u0131k de\u011Ferinin ba\u015Flang\u0131\xE7 kolayl\u0131\u011F\u0131na maksimum katk\u0131s\u0131.",
  LOGGING: "Kay\u0131t tutma",
  DISPLAY_SCHEDULING_DEBUG_INFO: "Geli\u015Ftirici konsolunda hata ay\u0131klama bilgilerini g\xF6ster",
  DISPLAY_PARSER_DEBUG_INFO: "Ayr\u0131\u015Ft\u0131r\u0131c\u0131 i\xE7in hata ay\u0131klama bilgilerini geli\u015Ftirici konsolunda g\xF6ster",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "Not \u0130nceleme S\u0131ras\u0131",
  CLOSE: "Kapat",
  NEW: "Yeni",
  YESTERDAY: "D\xFCn",
  TODAY: "Bug\xFCn",
  TOMORROW: "Yar\u0131n",
  // stats-modal.tsx
  STATS_TITLE: "\u0130statistikler",
  MONTH: "Ay",
  QUARTER: "\xC7eyrek",
  YEAR: "Y\u0131l",
  LIFETIME: "\xD6m\xFCr Boyu",
  FORECAST: "Tahmin",
  FORECAST_DESC: "Gelecekte incelemeye al\u0131nacak kartlar\u0131n say\u0131s\u0131",
  SCHEDULED: "Planlanm\u0131\u015F",
  DAYS: "G\xFCnler",
  NUMBER_OF_CARDS: "Kart Say\u0131s\u0131",
  REVIEWS_PER_DAY: "Ortalama: ${avg} inceleme/g\xFCn",
  INTERVALS: "Aral\u0131klar",
  INTERVALS_DESC: "\u0130ncelemelerin tekrar g\xF6sterilme gecikmeleri",
  COUNT: "Say\u0131",
  INTERVALS_SUMMARY: "Ortalama aral\u0131k: ${avg}, En uzun aral\u0131k: ${longest}",
  EASES: "Kolayl\u0131klar",
  EASES_SUMMARY: "Ortalama kolayl\u0131k: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "Kart T\xFCrleri",
  CARD_TYPES_DESC: "Bu, g\xF6m\xFCl\xFC kartlar\u0131 da i\xE7erir (varsa)",
  CARD_TYPE_NEW: "Yeni",
  CARD_TYPE_YOUNG: "Gen\xE7",
  CARD_TYPE_MATURE: "Olgun",
  CARD_TYPES_SUMMARY: "Toplam kart: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var tr_default = tr;

// src/lang/locale/uk.ts
var uk = {
  ...en_default,
  language: "uk",
  languageName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430",
  // flashcard-modal.tsx
  DECKS: "\u041A\u043E\u043B\u043E\u0434\u0438 \u043A\u0430\u0440\u0442\u043E\u043A",
  DUE_CARDS: "\u041A\u0430\u0440\u0442\u043A\u0438 \u0434\u043E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  NEW_CARDS: "\u041D\u043E\u0432\u0456 \u043A\u0430\u0440\u0442\u043A\u0438",
  TOTAL_CARDS: "\u0423\u0441\u044C\u043E\u0433\u043E \u043A\u0430\u0440\u0442\u043E\u043A",
  BACK: "\u041D\u0430\u0437\u0430\u0434",
  SKIP: "\u041F\u0440\u043E\u043F\u0443\u0441\u0442\u0438\u0442\u0438",
  EDIT_CARD: "\u0420\u0435\u0434\u0430\u0433\u0443\u0432\u0430\u0442\u0438 \u043A\u0430\u0440\u0442\u043A\u0443",
  RESET_CARD_PROGRESS: "\u0421\u043A\u0438\u043D\u0443\u0442\u0438 \u043F\u0440\u043E\u0433\u0440\u0435\u0441 \u043A\u0430\u0440\u0442\u043A\u0438",
  HARD: "\u0412\u0430\u0436\u043A\u043E",
  GOOD: "\u0414\u043E\u0431\u0440\u0435",
  EASY: "\u041B\u0435\u0433\u043A\u043E",
  SHOW_ANSWER: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u0438 \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u044C",
  CARD_PROGRESS_RESET: "\u041F\u0440\u043E\u0433\u0440\u0435\u0441 \u043A\u0430\u0440\u0442\u043A\u0438 \u0441\u043A\u0438\u043D\u0443\u0442\u043E.",
  SAVE: "\u0417\u0431\u0435\u0440\u0435\u0433\u0442\u0438",
  CANCEL: "\u0421\u043A\u0430\u0441\u0443\u0432\u0430\u0442\u0438",
  NO_INPUT: "\u0414\u0430\u043D\u0456 \u043D\u0435 \u0432\u0432\u0435\u0434\u0435\u043D\u043E.",
  CURRENT_EASE_HELP_TEXT: "\u041F\u043E\u0442\u043E\u0447\u043D\u0438\u0439 \u043A\u043E\u0435\u0444\u0456\u0446\u0456\u0454\u043D\u0442 \u043B\u0435\u0433\u043A\u043E\u0441\u0442\u0456: ",
  CURRENT_INTERVAL_HELP_TEXT: "\u041F\u043E\u0442\u043E\u0447\u043D\u0438\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B: ",
  CARD_GENERATED_FROM: "\u0421\u0442\u0432\u043E\u0440\u0435\u043D\u043E \u0437: ${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\u0412\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \u043D\u043E\u0442\u0430\u0442\u043A\u0443 \u0434\u043B\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  REVIEW_CARDS: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438 \u043A\u0430\u0440\u0442\u043A\u0438",
  REVIEW_DIFFICULTY_FILE_MENU: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438: ${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438 \u043D\u043E\u0442\u0430\u0442\u043A\u0443 \u044F\u043A ${difficulty}",
  CRAM_ALL_CARDS: "\u0412\u0438\u0431\u0440\u0430\u0442\u0438 \u043A\u043E\u043B\u043E\u0434\u0443 \u0434\u043B\u044F \u0456\u043D\u0442\u0435\u043D\u0441\u0438\u0432\u043D\u043E\u0433\u043E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  REVIEW_ALL_CARDS: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438 \u043A\u0430\u0440\u0442\u043A\u0438 \u0437 \u0443\u0441\u0456\u0445 \u043D\u043E\u0442\u0430\u0442\u043E\u043A",
  REVIEW_CARDS_IN_NOTE: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438 \u043A\u0430\u0440\u0442\u043A\u0438 \u0432 \u0446\u0456\u0439 \u043D\u043E\u0442\u0430\u0442\u0446\u0456",
  CRAM_CARDS_IN_NOTE: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438 \u043A\u0430\u0440\u0442\u043A\u0438 \u0446\u0456\u0454\u0457 \u043D\u043E\u0442\u0430\u0442\u043A\u0438",
  VIEW_STATS: "\u041F\u0435\u0440\u0435\u0433\u043B\u044F\u043D\u0443\u0442\u0438 \u0441\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043A\u0443",
  OPEN_REVIEW_QUEUE_VIEW: "\u0412\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \u0447\u0435\u0440\u0433\u0443 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043A\u0430\u0440\u0442\u043E\u043A \u0443 \u0431\u0456\u0447\u043D\u0456\u0439 \u043F\u0430\u043D\u0435\u043B\u0456",
  STATUS_BAR: "\u041F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F: \u043D\u043E\u0442\u0430\u0442\u043E\u043A \u2014 ${dueNotesCount}, \u043A\u0430\u0440\u0442\u043E\u043A \u2014 ${dueFlashcardsCount}",
  SYNC_TIME_TAKEN: "\u0421\u0438\u043D\u0445\u0440\u043E\u043D\u0456\u0437\u0430\u0446\u0456\u044F: ${t} \u043C\u0441",
  NOTE_IN_IGNORED_FOLDER: "\u041D\u043E\u0442\u0430\u0442\u043A\u0443 \u0437\u0431\u0435\u0440\u0435\u0436\u0435\u043D\u043E \u0432 \u043F\u0440\u043E\u0456\u0433\u043D\u043E\u0440\u043E\u0432\u0430\u043D\u0456\u0439 \u0442\u0435\u0446\u0456 (\u043F\u0435\u0440\u0435\u0432\u0456\u0440\u0442\u0435 \u043D\u0430\u043B\u0430\u0448\u0442\u0443\u0432\u0430\u043D\u043D\u044F).",
  PLEASE_TAG_NOTE: "\u0411\u0443\u0434\u044C \u043B\u0430\u0441\u043A\u0430, \u043F\u043E\u0437\u043D\u0430\u0447\u0442\u0435 \u043D\u043E\u0442\u0430\u0442\u043A\u0443 \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u043D\u0438\u043C\u0438 \u0442\u0435\u0433\u0430\u043C\u0438 \u0434\u043B\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F (\u0443 \u043D\u0430\u043B\u0430\u0448\u0442\u0443\u0432\u0430\u043D\u043D\u044F\u0445).",
  RESPONSE_RECEIVED: "\u0412\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u044C \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E.",
  NO_DECK_EXISTS: "\u041A\u043E\u043B\u043E\u0434\u0438 \xAB${deckName}\xBB \u043D\u0435 \u0456\u0441\u043D\u0443\u0454",
  ALL_CAUGHT_UP: "\u0427\u0443\u0434\u043E\u0432\u043E! \u0423\u0441\u0456 \u043A\u0430\u0440\u0442\u043A\u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043E :D",
  // scheduling.ts
  DAYS_STR_IVL: "${interval} \u0434\u043D.",
  MONTHS_STR_IVL: "${interval} \u043C\u0456\u0441.",
  YEARS_STR_IVL: "${interval} \u0440.",
  DAYS_STR_IVL_MOBILE: "${interval}\u0434",
  MONTHS_STR_IVL_MOBILE: "${interval}\u043C",
  YEARS_STR_IVL_MOBILE: "${interval}\u0440",
  // settings.ts
  SETTINGS_HEADER: "\u041F\u043B\u0430\u0433\u0456\u043D Spaced Repetition \u0434\u043B\u044F Obsidian",
  GROUP_TAGS_FOLDERS: "\u0422\u0435\u0433\u0438 \u0442\u0430 \u0442\u0435\u043A\u0438",
  GROUP_FLASHCARD_REVIEW: "\u041F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043A\u0430\u0440\u0442\u043E\u043A",
  GROUP_FLASHCARD_SEPARATORS: "\u0420\u043E\u0437\u0434\u0456\u043B\u044C\u043D\u0438\u043A\u0438 \u043A\u0430\u0440\u0442\u043E\u043A",
  GROUP_DATA_STORAGE: "\u0417\u0431\u0435\u0440\u0456\u0433\u0430\u043D\u043D\u044F \u0434\u0430\u043D\u0438\u0445 \u043F\u043B\u0430\u043D\u0443\u0432\u0430\u043D\u043D\u044F",
  GROUP_DATA_STORAGE_DESC: "\u041E\u0431\u0435\u0440\u0456\u0442\u044C, \u0434\u0435 \u0437\u0431\u0435\u0440\u0456\u0433\u0430\u0442\u0438 \u0434\u0430\u043D\u0456 \u043F\u043B\u0430\u043D\u0443\u0432\u0430\u043D\u043D\u044F",
  GROUP_FLASHCARDS_NOTES: "\u041A\u0430\u0440\u0442\u043A\u0438 \u0442\u0430 \u043D\u043E\u0442\u0430\u0442\u043A\u0438",
  GROUP_CONTRIBUTING: "\u0412\u043D\u0435\u0441\u043E\u043A \u0443 \u043F\u0440\u043E\u0454\u043A\u0442",
  CHECK_WIKI: '\u0414\u043B\u044F \u0434\u043E\u043A\u043B\u0430\u0434\u043D\u0456\u0448\u043E\u0457 \u0456\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0456\u0457 \u043F\u0435\u0440\u0435\u0433\u043B\u044F\u043D\u044C\u0442\u0435 <a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: '\u0412\u0456\u0434\u0432\u0456\u0434\u0430\u0439\u0442\u0435 \u0440\u043E\u0437\u0434\u0456\u043B <a href="${discussionsUrl}">discussions</a> \u0434\u043B\u044F \u0437\u0430\u043F\u0438\u0442\u0430\u043D\u044C \u0456 \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0435\u0439, \u0432\u0456\u0434\u0433\u0443\u043A\u0456\u0432 \u0442\u0430 \u0437\u0430\u0433\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u043E\u0431\u0433\u043E\u0432\u043E\u0440\u0435\u043D\u043D\u044F.',
  GITHUB_ISSUES: '\u0421\u0442\u0432\u043E\u0440\u0456\u0442\u044C \u0437\u0432\u0435\u0440\u043D\u0435\u043D\u043D\u044F <a href="${issuesUrl}">\u0442\u0443\u0442</a>, \u044F\u043A\u0449\u043E \u043C\u0430\u0454\u0442\u0435 \u0437\u0430\u043F\u0438\u0442 \u043D\u0430 \u0444\u0443\u043D\u043A\u0446\u0456\u044E \u0430\u0431\u043E \u043F\u043E\u0432\u0456\u0434\u043E\u043C\u043B\u0435\u043D\u043D\u044F \u043F\u0440\u043E \u043F\u043E\u043C\u0438\u043B\u043A\u0443.',
  GITHUB_SOURCE_CODE: '\u0412\u0438\u0445\u0456\u0434\u043D\u0438\u0439 \u043A\u043E\u0434 \u043F\u0440\u043E\u0454\u043A\u0442\u0443 \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u0438\u0439 \u043D\u0430 <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">\u041E\u0441\u044C</a> \u044F\u043A \u0437\u0440\u043E\u0431\u0438\u0442\u0438 \u0432\u043D\u0435\u0441\u043E\u043A \u0443 \u043A\u043E\u0434 \u043F\u043B\u0430\u0433\u0456\u043D\u0430.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">\u041E\u0441\u044C</a> \u044F\u043A \u043F\u0435\u0440\u0435\u043A\u043B\u0430\u0441\u0442\u0438 \u043F\u043B\u0430\u0433\u0456\u043D \u043D\u0430 \u0456\u043D\u0448\u0443 \u043C\u043E\u0432\u0443.',
  FOLDERS_TO_IGNORE: "\u0422\u0435\u043A\u0438 \u0434\u043B\u044F \u0456\u0433\u043D\u043E\u0440\u0443\u0432\u0430\u043D\u043D\u044F",
  FOLDERS_TO_IGNORE_DESC: "\u0412\u0432\u0435\u0434\u0456\u0442\u044C \u0448\u043B\u044F\u0445\u0438 \u0442\u0435\u043A \u0430\u0431\u043E glob-\u0448\u0430\u0431\u043B\u043E\u043D\u0438 \u0432 \u043E\u043A\u0440\u0435\u043C\u0438\u0445 \u0440\u044F\u0434\u043A\u0430\u0445, \u043D\u0430\u043F\u0440. Templates/Scripts \u0430\u0431\u043E **/*.excalidraw.md. \u0426\u0435 \u043D\u0430\u043B\u0430\u0448\u0442\u0443\u0432\u0430\u043D\u043D\u044F \u0441\u043F\u0456\u043B\u044C\u043D\u0435 \u0434\u043B\u044F \u043A\u0430\u0440\u0442\u043E\u043A \u0456 \u043D\u043E\u0442\u0430\u0442\u043E\u043A.",
  OBSIDIAN_INTEGRATION: "\u0406\u043D\u0442\u0435\u0433\u0440\u0430\u0446\u0456\u044F \u0437 Obsidian",
  FLASHCARDS: "\u041A\u0430\u0440\u0442\u043A\u0438",
  FLASHCARD_EASY_LABEL: "\u0422\u0435\u043A\u0441\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 \xAB\u041B\u0435\u0433\u043A\u043E\xBB",
  FLASHCARD_GOOD_LABEL: "\u0422\u0435\u043A\u0441\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 \xAB\u0414\u043E\u0431\u0440\u0435\xBB",
  FLASHCARD_HARD_LABEL: "\u0422\u0435\u043A\u0441\u0442 \u043A\u043D\u043E\u043F\u043A\u0438 \xAB\u0412\u0430\u0436\u043A\u043E\xBB",
  FLASHCARD_EASY_DESC: "\u041D\u0430\u043B\u0430\u0448\u0442\u0443\u0439\u0442\u0435 \u043F\u0456\u0434\u043F\u0438\u0441 \u0434\u043B\u044F \u043A\u043D\u043E\u043F\u043A\u0438 \xAB\u041B\u0435\u0433\u043A\u043E\xBB",
  FLASHCARD_GOOD_DESC: "\u041D\u0430\u043B\u0430\u0448\u0442\u0443\u0439\u0442\u0435 \u043F\u0456\u0434\u043F\u0438\u0441 \u0434\u043B\u044F \u043A\u043D\u043E\u043F\u043A\u0438 \xAB\u0414\u043E\u0431\u0440\u0435\xBB",
  FLASHCARD_HARD_DESC: "\u041D\u0430\u043B\u0430\u0448\u0442\u0443\u0439\u0442\u0435 \u043F\u0456\u0434\u043F\u0438\u0441 \u0434\u043B\u044F \u043A\u043D\u043E\u043F\u043A\u0438 \xAB\u0412\u0430\u0436\u043A\u043E\xBB",
  REVIEW_BUTTON_DELAY: "\u0417\u0430\u0442\u0440\u0438\u043C\u043A\u0430 \u043D\u0430\u0442\u0438\u0441\u043A\u0430\u043D\u043D\u044F \u043A\u043D\u043E\u043F\u043A\u0438 (\u043C\u0441)",
  REVIEW_BUTTON_DELAY_DESC: "\u0414\u043E\u0434\u0430\u0439\u0442\u0435 \u0437\u0430\u0442\u0440\u0438\u043C\u043A\u0443 \u0434\u043E \u043A\u043D\u043E\u043F\u043E\u043A \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F, \u043F\u0435\u0440\u0448 \u043D\u0456\u0436 \u0457\u0445 \u043C\u043E\u0436\u043D\u0430 \u0431\u0443\u0434\u0435 \u043D\u0430\u0442\u0438\u0441\u043D\u0443\u0442\u0438 \u0437\u043D\u043E\u0432\u0443.",
  FLASHCARD_TAGS: "\u0422\u0435\u0433\u0438 \u043A\u0430\u0440\u0442\u043E\u043A",
  FLASHCARD_TAGS_DESC: "\u0412\u0432\u0435\u0434\u0456\u0442\u044C \u0442\u0435\u0433\u0438, \u0440\u043E\u0437\u0434\u0456\u043B\u0435\u043D\u0456 \u043F\u0440\u043E\u0431\u0456\u043B\u0430\u043C\u0438 \u0430\u0431\u043E \u043D\u043E\u0432\u0438\u043C\u0438 \u0440\u044F\u0434\u043A\u0430\u043C\u0438 (\u043D\u0430\u043F\u0440. #flashcards #deck2 #deck3).",
  CONVERT_FOLDERS_TO_DECKS: "\u041F\u0435\u0440\u0435\u0442\u0432\u043E\u0440\u044E\u0432\u0430\u0442\u0438 \u0442\u0435\u043A\u0438 \u043D\u0430 \u043A\u043E\u043B\u043E\u0434\u0438",
  CONVERT_FOLDERS_TO_DECKS_DESC: "\u0426\u0435 \u0430\u043B\u044C\u0442\u0435\u0440\u043D\u0430\u0442\u0438\u0432\u043D\u0438\u0439 \u0432\u0430\u0440\u0456\u0430\u043D\u0442 \u0434\u043E \u0442\u0435\u0433\u0456\u0432 \u043A\u0430\u0440\u0442\u043E\u043A \u0432\u0438\u0449\u0435.",
  INLINE_SCHEDULING_COMMENTS: "\u0417\u0431\u0435\u0440\u0456\u0433\u0430\u0442\u0438 \u043A\u043E\u043C\u0435\u043D\u0442\u0430\u0440 \u043F\u043B\u0430\u043D\u0443\u0432\u0430\u043D\u043D\u044F \u0432 \u0442\u043E\u043C\u0443 \u0436 \u0440\u044F\u0434\u043A\u0443, \u0449\u043E \u0439 \u043E\u0441\u0442\u0430\u043D\u043D\u0456\u0439 \u0440\u044F\u0434\u043E\u043A \u043A\u0430\u0440\u0442\u043A\u0438?",
  INLINE_SCHEDULING_COMMENTS_DESC: "\u0423\u0432\u0456\u043C\u043A\u043D\u0435\u043D\u043D\u044F \u0446\u044C\u043E\u0433\u043E \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 \u043D\u0435 \u0434\u0430\u0441\u0442\u044C HTML-\u043A\u043E\u043C\u0435\u043D\u0442\u0430\u0440\u044F\u043C \u043B\u0430\u043C\u0430\u0442\u0438 \u0444\u043E\u0440\u043C\u0430\u0442\u0443\u0432\u0430\u043D\u043D\u044F \u0441\u043F\u0438\u0441\u043A\u0456\u0432.",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\u0412\u0456\u0434\u043A\u043B\u0430\u0434\u0430\u0442\u0438 \u0441\u043F\u043E\u0440\u0456\u0434\u043D\u0435\u043D\u0456 \u043A\u0430\u0440\u0442\u043A\u0438 \u0434\u043E \u043D\u0430\u0441\u0442\u0443\u043F\u043D\u043E\u0433\u043E \u0434\u043D\u044F",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "\u0421\u043F\u043E\u0440\u0456\u0434\u043D\u0435\u043D\u0456 \u2014 \u0446\u0435 \u043A\u0430\u0440\u0442\u043A\u0438, \u0441\u0442\u0432\u043E\u0440\u0435\u043D\u0456 \u0437 \u043E\u0434\u043D\u043E\u0433\u043E \u0439 \u0442\u043E\u0433\u043E \u0441\u0430\u043C\u043E\u0433\u043E \u0442\u0435\u043A\u0441\u0442\u0443, \u043D\u0430\u043F\u0440. cloze-\u0432\u0438\u043B\u0443\u0447\u0435\u043D\u043D\u044F",
  SHOW_CARD_CONTEXT: "\u041F\u043E\u043A\u0430\u0437\u0443\u0432\u0430\u0442\u0438 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442 \u0443 \u043A\u0430\u0440\u0442\u043A\u0430\u0445",
  SHOW_CARD_CONTEXT_DESC: "\u043D\u0430\u043F\u0440. \u041D\u0430\u0437\u0432\u0430 > \u0417\u0430\u0433\u043E\u043B\u043E\u0432\u043E\u043A 1 > \u041F\u0456\u0434\u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043E\u043A > ... > \u041F\u0456\u0434\u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043E\u043A",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "\u041F\u043E\u043A\u0430\u0437\u0443\u0432\u0430\u0442\u0438 \u0447\u0430\u0441 \u0434\u043E \u043D\u0430\u0441\u0442\u0443\u043F\u043D\u043E\u0433\u043E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043D\u0430 \u043A\u043D\u043E\u043F\u043A\u0430\u0445",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "\u041A\u043E\u0440\u0438\u0441\u043D\u043E \u0437\u043D\u0430\u0442\u0438, \u043D\u0430\u0441\u043A\u0456\u043B\u044C\u043A\u0438 \u0434\u0430\u043B\u0435\u043A\u043E \u0432 \u043C\u0430\u0439\u0431\u0443\u0442\u043D\u0454 \u0432\u0456\u0434\u0441\u0443\u0432\u0430\u044E\u0442\u044C\u0441\u044F \u0432\u0430\u0448\u0456 \u043A\u0430\u0440\u0442\u043A\u0438.",
  CARD_MODAL_HEIGHT_PERCENT: "\u0412\u0456\u0434\u0441\u043E\u0442\u043E\u043A \u0432\u0438\u0441\u043E\u0442\u0438 \u043A\u0430\u0440\u0442\u043A\u0438",
  CARD_MODAL_SIZE_PERCENT_DESC: "\u0414\u043B\u044F \u043C\u043E\u0431\u0456\u043B\u044C\u043D\u0438\u0445 \u0430\u0431\u043E \u044F\u043A\u0449\u043E \u043C\u0430\u0454\u0442\u0435 \u0434\u0443\u0436\u0435 \u0432\u0435\u043B\u0438\u043A\u0456 \u0437\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u043D\u044F, \u0432\u0441\u0442\u0430\u043D\u043E\u0432\u0456\u0442\u044C 100%",
  RESET_DEFAULT: "\u0421\u043A\u0438\u043D\u0443\u0442\u0438 \u0434\u043E \u0442\u0438\u043F\u043E\u0432\u0438\u0445",
  CARD_MODAL_WIDTH_PERCENT: "\u0412\u0456\u0434\u0441\u043E\u0442\u043E\u043A \u0448\u0438\u0440\u0438\u043D\u0438 \u043A\u0430\u0440\u0442\u043A\u0438",
  RANDOMIZE_CARD_ORDER: "\u041F\u0435\u0440\u0435\u043C\u0456\u0448\u0443\u0432\u0430\u0442\u0438 \u043F\u043E\u0440\u044F\u0434\u043E\u043A \u043A\u0430\u0440\u0442\u043E\u043A \u043F\u0456\u0434 \u0447\u0430\u0441 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F?",
  REVIEW_CARD_ORDER_WITHIN_DECK: "\u041F\u043E\u0440\u044F\u0434\u043E\u043A \u043A\u0430\u0440\u0442\u043E\u043A \u0443 \u043A\u043E\u043B\u043E\u0434\u0456",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "\u041F\u043E\u0441\u043B\u0456\u0434\u043E\u0432\u043D\u043E \u0432 \u043C\u0435\u0436\u0430\u0445 \u043A\u043E\u043B\u043E\u0434\u0438 (\u0441\u043F\u043E\u0447\u0430\u0442\u043A\u0443 \u0432\u0441\u0456 \u043D\u043E\u0432\u0456 \u043A\u0430\u0440\u0442\u043A\u0438)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "\u041F\u043E\u0441\u043B\u0456\u0434\u043E\u0432\u043D\u043E \u0432 \u043C\u0435\u0436\u0430\u0445 \u043A\u043E\u043B\u043E\u0434\u0438 (\u0441\u043F\u043E\u0447\u0430\u0442\u043A\u0443 \u0432\u0441\u0456 \u0434\u043E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "\u0412\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u043E \u0432 \u043C\u0435\u0436\u0430\u0445 \u043A\u043E\u043B\u043E\u0434\u0438 (\u0441\u043F\u043E\u0447\u0430\u0442\u043A\u0443 \u0432\u0441\u0456 \u043D\u043E\u0432\u0456 \u043A\u0430\u0440\u0442\u043A\u0438)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "\u0412\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u043E \u0432 \u043C\u0435\u0436\u0430\u0445 \u043A\u043E\u043B\u043E\u0434\u0438 (\u0441\u043F\u043E\u0447\u0430\u0442\u043A\u0443 \u0432\u0441\u0456 \u0434\u043E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "\u0412\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u0430 \u043A\u0430\u0440\u0442\u043A\u0430 \u0437 \u0432\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u043E\u0457 \u043A\u043E\u043B\u043E\u0434\u0438",
  REVIEW_DECK_ORDER: "\u041F\u043E\u0440\u044F\u0434\u043E\u043A \u0432\u0456\u0434\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u043D\u044F \u043A\u043E\u043B\u043E\u0434 \u043F\u0456\u0434 \u0447\u0430\u0441 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "\u041F\u043E\u0441\u043B\u0456\u0434\u043E\u0432\u043D\u043E (\u043F\u0456\u0441\u043B\u044F \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u043D\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u0432\u0441\u0456\u0445 \u043A\u0430\u0440\u0442\u043E\u043A \u0443 \u043F\u043E\u043F\u0435\u0440\u0435\u0434\u043D\u0456\u0439 \u043A\u043E\u043B\u043E\u0434\u0456)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "\u0412\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u043E (\u043F\u0456\u0441\u043B\u044F \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u043D\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u0432\u0441\u0456\u0445 \u043A\u0430\u0440\u0442\u043E\u043A \u0443 \u043F\u043E\u043F\u0435\u0440\u0435\u0434\u043D\u0456\u0439 \u043A\u043E\u043B\u043E\u0434\u0456)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "\u0412\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u0430 \u043A\u0430\u0440\u0442\u043A\u0430 \u0437 \u0432\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u043E\u0457 \u043A\u043E\u043B\u043E\u0434\u0438",
  DISABLE_CLOZE_CARDS: "\u0412\u0438\u043C\u043A\u043D\u0443\u0442\u0438 cloze-\u043A\u0430\u0440\u0442\u043A\u0438?",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "\u041F\u0435\u0440\u0435\u0442\u0432\u043E\u0440\u044E\u0432\u0430\u0442\u0438 ==\u0432\u0438\u0434\u0456\u043B\u0435\u043D\u043D\u044F== \u043D\u0430 cloze",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: "\u0414\u043E\u0434\u0430\u0439\u0442\u0435/\u0432\u0438\u0434\u0430\u043B\u0456\u0442\u044C <code>${defaultPattern}</code> \u0443 \u0432\u0430\u0448\u0438\u0445 cloze-\u0448\u0430\u0431\u043B\u043E\u043D\u0430\u0445",
  CONVERT_BOLD_TEXT_TO_CLOZES: "\u041F\u0435\u0440\u0435\u0442\u0432\u043E\u0440\u044E\u0432\u0430\u0442\u0438 **\u0436\u0438\u0440\u043D\u0438\u0439 \u0442\u0435\u043A\u0441\u0442** \u043D\u0430 cloze",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: "\u0414\u043E\u0434\u0430\u0439\u0442\u0435/\u0432\u0438\u0434\u0430\u043B\u0456\u0442\u044C <code>${defaultPattern}</code> \u0443 \u0432\u0430\u0448\u0438\u0445 cloze-\u0448\u0430\u0431\u043B\u043E\u043D\u0430\u0445",
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "\u041F\u0435\u0440\u0435\u0442\u0432\u043E\u0440\u044E\u0432\u0430\u0442\u0438 {{\u0444\u0456\u0433\u0443\u0440\u043D\u0456 \u0434\u0443\u0436\u043A\u0438}} \u043D\u0430 cloze",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: "\u0414\u043E\u0434\u0430\u0439\u0442\u0435/\u0432\u0438\u0434\u0430\u043B\u0456\u0442\u044C <code>${defaultPattern}</code> \u0443 \u0432\u0430\u0448\u0438\u0445 cloze-\u0448\u0430\u0431\u043B\u043E\u043D\u0430\u0445",
  CLOZE_PATTERNS: "Cloze-\u0448\u0430\u0431\u043B\u043E\u043D\u0438",
  CLOZE_PATTERNS_DESC: '\u0412\u0432\u0435\u0434\u0456\u0442\u044C cloze-\u0448\u0430\u0431\u043B\u043E\u043D\u0438, \u0440\u043E\u0437\u0434\u0456\u043B\u0435\u043D\u0456 \u043D\u043E\u0432\u0438\u043C\u0438 \u0440\u044F\u0434\u043A\u0430\u043C\u0438. \u041F\u0435\u0440\u0435\u0433\u043B\u044F\u043D\u044C\u0442\u0435 <a href="${docsUrl}">wiki</a> \u0434\u043B\u044F \u0434\u043E\u0432\u0456\u0434\u043A\u0438.',
  INLINE_CARDS_SEPARATOR: "\u0420\u043E\u0437\u0434\u0456\u043B\u044C\u043D\u0438\u043A \u0434\u043B\u044F \u0440\u044F\u0434\u043A\u043E\u0432\u0438\u0445 \u043A\u0430\u0440\u0442\u043E\u043A",
  FIX_SEPARATORS_MANUALLY_WARNING: "\u041F\u0456\u0441\u043B\u044F \u0437\u043C\u0456\u043D\u0438 \u0446\u044C\u043E\u0433\u043E \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 \u043F\u043E\u0442\u0440\u0456\u0431\u043D\u043E \u0432\u0440\u0443\u0447\u043D\u0443 \u0432\u0456\u0434\u0440\u0435\u0434\u0430\u0433\u0443\u0432\u0430\u0442\u0438 \u0432\u0441\u0456 \u043D\u0430\u044F\u0432\u043D\u0456 \u043A\u0430\u0440\u0442\u043A\u0438.",
  INLINE_REVERSED_CARDS_SEPARATOR: "\u0420\u043E\u0437\u0434\u0456\u043B\u044C\u043D\u0438\u043A \u0434\u043B\u044F \u0440\u044F\u0434\u043A\u043E\u0432\u0438\u0445 \u0434\u0432\u043E\u0431\u0456\u0447\u043D\u0438\u0445 \u043A\u0430\u0440\u0442\u043E\u043A",
  MULTILINE_CARDS_SEPARATOR: "\u0420\u043E\u0437\u0434\u0456\u043B\u044C\u043D\u0438\u043A \u0434\u043B\u044F \u0431\u0430\u0433\u0430\u0442\u043E\u0440\u044F\u0434\u043A\u043E\u0432\u0438\u0445 \u043A\u0430\u0440\u0442\u043E\u043A",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\u0420\u043E\u0437\u0434\u0456\u043B\u044C\u043D\u0438\u043A \u0434\u043B\u044F \u0431\u0430\u0433\u0430\u0442\u043E\u0440\u044F\u0434\u043A\u043E\u0432\u0438\u0445 \u0434\u0432\u043E\u0431\u0456\u0447\u043D\u0438\u0445 \u043A\u0430\u0440\u0442\u043E\u043A",
  MULTILINE_CARDS_END_MARKER: "\u0421\u0438\u043C\u0432\u043E\u043B\u0438, \u0449\u043E \u043F\u043E\u0437\u043D\u0430\u0447\u0430\u044E\u0442\u044C \u043A\u0456\u043D\u0435\u0446\u044C cloze \u0442\u0430 \u0431\u0430\u0433\u0430\u0442\u043E\u0440\u044F\u0434\u043A\u043E\u0432\u0438\u0445 \u043A\u0430\u0440\u0442\u043E\u043A",
  NOTES: "\u041D\u043E\u0442\u0430\u0442\u043A\u0438",
  NOTE: "\u041D\u043E\u0442\u0430\u0442\u043A\u0430",
  REVIEW_PANE_ON_STARTUP: "\u0423\u0432\u0456\u043C\u043A\u043D\u0443\u0442\u0438 \u043F\u0430\u043D\u0435\u043B\u044C \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043D\u043E\u0442\u0430\u0442\u043E\u043A \u043F\u0456\u0434 \u0447\u0430\u0441 \u0437\u0430\u043F\u0443\u0441\u043A\u0443",
  TAGS_TO_REVIEW: "\u0422\u0435\u0433\u0438 \u0434\u043B\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  TAGS_TO_REVIEW_DESC: "\u0412\u0432\u0435\u0434\u0456\u0442\u044C \u0442\u0435\u0433\u0438, \u0440\u043E\u0437\u0434\u0456\u043B\u0435\u043D\u0456 \u043F\u0440\u043E\u0431\u0456\u043B\u0430\u043C\u0438 \u0430\u0431\u043E \u043D\u043E\u0432\u0438\u043C\u0438 \u0440\u044F\u0434\u043A\u0430\u043C\u0438, \u043D\u0430\u043F\u0440. #review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "\u0412\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \u0432\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u0443 \u043D\u043E\u0442\u0430\u0442\u043A\u0443 \u0434\u043B\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  OPEN_RANDOM_NOTE_DESC: "\u041A\u043E\u043B\u0438 \u0432\u0438\u043C\u043A\u043D\u0435\u043D\u043E, \u043D\u043E\u0442\u0430\u0442\u043A\u0438 \u0432\u043F\u043E\u0440\u044F\u0434\u043A\u043E\u0432\u0443\u044E\u0442\u044C\u0441\u044F \u0437\u0430 \u0432\u0430\u0436\u043B\u0438\u0432\u0456\u0441\u0442\u044E (PageRank).",
  AUTO_NEXT_NOTE: "\u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u043D\u043E \u0432\u0456\u0434\u043A\u0440\u0438\u0432\u0430\u0442\u0438 \u043D\u0430\u0441\u0442\u0443\u043F\u043D\u0443 \u043D\u043E\u0442\u0430\u0442\u043A\u0443 \u043F\u0456\u0441\u043B\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F",
  MAX_N_DAYS_REVIEW_QUEUE: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0430 \u043A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044C \u0434\u043D\u0456\u0432 \u0443 \u043F\u0430\u043D\u0435\u043B\u0456 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043D\u043E\u0442\u0430\u0442\u043E\u043A",
  MIN_ONE_DAY: "\u041A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044C \u0434\u043D\u0456\u0432 \u043C\u0430\u0454 \u0431\u0443\u0442\u0438 \u0449\u043E\u043D\u0430\u0439\u043C\u0435\u043D\u0448\u0435 1.",
  VALID_NUMBER_WARNING: "\u0411\u0443\u0434\u044C \u043B\u0430\u0441\u043A\u0430, \u0432\u0432\u0435\u0434\u0456\u0442\u044C \u043A\u043E\u0440\u0435\u043A\u0442\u043D\u0435 \u0447\u0438\u0441\u043B\u043E.",
  UI: "\u0406\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441",
  OPEN_IN_TAB: "\u0412\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \u0432 \u043D\u043E\u0432\u0456\u0439 \u0432\u043A\u043B\u0430\u0434\u0446\u0456",
  OPEN_IN_TAB_DESC: "\u0412\u0438\u043C\u043A\u043D\u0456\u0442\u044C, \u0449\u043E\u0431 \u0432\u0456\u0434\u043A\u0440\u0438\u0432\u0430\u0442\u0438 \u043F\u043B\u0430\u0433\u0456\u043D \u0443 \u043C\u043E\u0434\u0430\u043B\u044C\u043D\u043E\u043C\u0443 \u0432\u0456\u043A\u043D\u0456",
  SHOW_STATUS_BAR: "\u041F\u043E\u043A\u0430\u0437\u0443\u0432\u0430\u0442\u0438 \u0440\u044F\u0434\u043E\u043A \u0441\u0442\u0430\u043D\u0443",
  SHOW_STATUS_BAR_DESC: "\u0412\u0438\u043C\u043A\u043D\u0456\u0442\u044C, \u0449\u043E\u0431 \u043F\u0440\u0438\u0445\u043E\u0432\u0430\u0442\u0438 \u0441\u0442\u0430\u043D \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043A\u0430\u0440\u0442\u043E\u043A \u0443 \u0440\u044F\u0434\u043A\u0443 \u0441\u0442\u0430\u043D\u0443 Obsidian",
  SHOW_RIBBON_ICON: "\u041F\u043E\u043A\u0430\u0437\u0443\u0432\u0430\u0442\u0438 \u0456\u043A\u043E\u043D\u043A\u0443 \u043D\u0430 \u0441\u0442\u0440\u0456\u0447\u0446\u0456",
  SHOW_RIBBON_ICON_DESC: "\u0412\u0438\u043C\u043A\u043D\u0456\u0442\u044C, \u0449\u043E\u0431 \u043F\u0440\u0438\u0445\u043E\u0432\u0430\u0442\u0438 \u0456\u043A\u043E\u043D\u043A\u0443 \u043F\u043B\u0430\u0433\u0456\u043D\u0430 \u0437\u0456 \u0441\u0442\u0440\u0456\u0447\u043A\u0438 Obsidian",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\u0423\u0432\u0456\u043C\u043A\u043D\u0443\u0442\u0438 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u0432 \u043C\u0435\u043D\u044E \u0444\u0430\u0439\u043B\u0443 (\u043D\u0430\u043F\u0440. \u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438: \u041B\u0435\u0433\u043A\u043E, \u0414\u043E\u0431\u0440\u0435, \u0412\u0430\u0436\u043A\u043E)",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\u042F\u043A\u0449\u043E \u0432\u0438\u043C\u043A\u043D\u0443\u0442\u0438 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u0432 \u043C\u0435\u043D\u044E \u0444\u0430\u0439\u043B\u0443, \u0432\u0438 \u0437\u043C\u043E\u0436\u0435\u0442\u0435 \u043F\u043E\u0432\u0442\u043E\u0440\u044E\u0432\u0430\u0442\u0438 \u043D\u043E\u0442\u0430\u0442\u043A\u0438 \u0437\u0430 \u0434\u043E\u043F\u043E\u043C\u043E\u0433\u043E\u044E \u043A\u043E\u043C\u0430\u043D\u0434 \u043F\u043B\u0430\u0433\u0456\u043D\u0430 \u0442\u0430, \u044F\u043A\u0449\u043E \u043D\u0430\u043B\u0430\u0448\u0442\u043E\u0432\u0430\u043D\u0456, \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u043D\u0438\u0445 \u0433\u0430\u0440\u044F\u0447\u0438\u0445 \u043A\u043B\u0430\u0432\u0456\u0448.",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\u0414\u0435\u0440\u0435\u0432\u043E \u043A\u043E\u043B\u043E\u0434 \u0441\u043F\u043E\u0447\u0430\u0442\u043A\u0443 \u043C\u0430\u0454 \u0431\u0443\u0442\u0438 \u0440\u043E\u0437\u0433\u043E\u0440\u043D\u0443\u0442\u0438\u043C",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "\u0412\u0438\u043C\u043A\u043D\u0456\u0442\u044C, \u0449\u043E\u0431 \u0437\u0433\u043E\u0440\u043D\u0443\u0442\u0438 \u0432\u043A\u043B\u0430\u0434\u0435\u043D\u0456 \u043A\u043E\u043B\u043E\u0434\u0438 \u0432 \u0442\u0456\u0439 \u0441\u0430\u043C\u0456\u0439 \u043A\u0430\u0440\u0442\u0446\u0456. \u041A\u043E\u0440\u0438\u0441\u043D\u043E, \u044F\u043A\u0449\u043E \u0432\u0430\u0448\u0456 \u043A\u0430\u0440\u0442\u043A\u0438 \u043D\u0430\u043B\u0435\u0436\u0430\u0442\u044C \u0434\u043E \u0431\u0430\u0433\u0430\u0442\u044C\u043E\u0445 \u043A\u043E\u043B\u043E\u0434 \u0432 \u043E\u0434\u043D\u043E\u043C\u0443 \u0444\u0430\u0439\u043B\u0456.",
  ALGORITHM: "\u0410\u043B\u0433\u043E\u0440\u0438\u0442\u043C",
  CHECK_ALGORITHM_WIKI: '\u0414\u043B\u044F \u0434\u043E\u043A\u043B\u0430\u0434\u043D\u0456\u0448\u043E\u0457 \u0456\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0456\u0457 \u043F\u0435\u0440\u0435\u0433\u043B\u044F\u043D\u044C\u0442\u0435 <a href="${algoUrl}">\u0434\u0435\u0442\u0430\u043B\u0456 \u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C\u0443</a>.',
  SM2_OSR_VARIANT: "\u0412\u0430\u0440\u0456\u0430\u043D\u0442 SM-2 \u0432\u0456\u0434 OSR",
  BASE_EASE: "\u0411\u0430\u0437\u043E\u0432\u0430 \u043B\u0435\u0433\u043A\u0456\u0441\u0442\u044C",
  BASE_EASE_DESC: "\u043C\u0456\u043D\u0456\u043C\u0443\u043C = 130, \u0431\u0430\u0436\u0430\u043D\u043E \u043F\u0440\u0438\u0431\u043B\u0438\u0437\u043D\u043E 250.",
  BASE_EASE_MIN_WARNING: "\u0411\u0430\u0437\u043E\u0432\u0430 \u043B\u0435\u0433\u043A\u0456\u0441\u0442\u044C \u043C\u0430\u0454 \u0431\u0443\u0442\u0438 \u0449\u043E\u043D\u0430\u0439\u043C\u0435\u043D\u0448\u0435 130.",
  LAPSE_INTERVAL_CHANGE: "\u0417\u043C\u0456\u043D\u0430 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0443 \u043F\u0440\u0438 \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0456 \xAB\u0412\u0430\u0436\u043A\u043E\xBB \u0434\u043B\u044F \u043A\u0430\u0440\u0442\u043A\u0438/\u043D\u043E\u0442\u0430\u0442\u043A\u0438",
  LAPSE_INTERVAL_CHANGE_DESC: "\u043D\u043E\u0432\u0438\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B = \u0441\u0442\u0430\u0440\u0438\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B \xD7 \u0437\u043C\u0456\u043D\u0430 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0443 / 100.",
  EASY_BONUS: "\u0411\u043E\u043D\u0443\u0441 \xAB\u041B\u0435\u0433\u043A\u043E\xBB",
  EASY_BONUS_DESC: "\u0411\u043E\u043D\u0443\u0441 \xAB\u041B\u0435\u0433\u043A\u043E\xBB \u0434\u0430\u0454 \u0437\u043C\u043E\u0433\u0443 \u0437\u0430\u0434\u0430\u0442\u0438 \u0440\u0456\u0437\u043D\u0438\u0446\u044E \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0456\u0432 \u043C\u0456\u0436 \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u044F\u043C\u0438 \xAB\u0414\u043E\u0431\u0440\u0435\xBB \u0456 \xAB\u041B\u0435\u0433\u043A\u043E\xBB \u0434\u043B\u044F \u043A\u0430\u0440\u0442\u043A\u0438/\u043D\u043E\u0442\u0430\u0442\u043A\u0438 (\u043C\u0456\u043D\u0456\u043C\u0443\u043C = 100%).",
  EASY_BONUS_MIN_WARNING: "\u0411\u043E\u043D\u0443\u0441 \xAB\u041B\u0435\u0433\u043A\u043E\xBB \u043C\u0430\u0454 \u0431\u0443\u0442\u0438 \u0449\u043E\u043D\u0430\u0439\u043C\u0435\u043D\u0448\u0435 100.",
  LOAD_BALANCE: "\u0423\u0432\u0456\u043C\u043A\u043D\u0443\u0442\u0438 \u0431\u0430\u043B\u0430\u043D\u0441\u0443\u0432\u0430\u043D\u043D\u044F \u043D\u0430\u0432\u0430\u043D\u0442\u0430\u0436\u0435\u043D\u043D\u044F",
  LOAD_BALANCE_DESC: `\u041D\u0435\u0437\u043D\u0430\u0447\u043D\u043E \u043A\u043E\u0440\u0438\u0433\u0443\u0454 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B, \u0449\u043E\u0431 \u043A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044C \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u044C \u043D\u0430 \u0434\u0435\u043D\u044C \u0431\u0443\u043B\u0430 \u0431\u0456\u043B\u044C\u0448 \u0440\u0456\u0432\u043D\u043E\u043C\u0456\u0440\u043D\u043E\u044E.
        \u0426\u0435 \u044F\u043A fuzz \u0432 Anki, \u0430\u043B\u0435 \u0437\u0430\u043C\u0456\u0441\u0442\u044C \u0432\u0438\u043F\u0430\u0434\u043A\u043E\u0432\u043E\u0441\u0442\u0456 \u043E\u0431\u0438\u0440\u0430\u0454\u0442\u044C\u0441\u044F \u0434\u0435\u043D\u044C \u0437 \u043D\u0430\u0439\u043C\u0435\u043D\u0448\u043E\u044E \u043A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u044C.
        \u0414\u043B\u044F \u043A\u043E\u0440\u043E\u0442\u043A\u0438\u0445 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0456\u0432 \u0432\u0438\u043C\u043A\u043D\u0435\u043D\u043E.`,
  MAX_INTERVAL: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0438\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B \u0443 \u0434\u043D\u044F\u0445",
  MAX_INTERVAL_DESC: "\u0414\u043E\u0437\u0432\u043E\u043B\u044F\u0454 \u0432\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0438 \u0432\u0435\u0440\u0445\u043D\u044E \u043C\u0435\u0436\u0443 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0443 (\u0442\u0438\u043F\u043E\u0432\u043E = 100 \u0440\u043E\u043A\u0456\u0432).",
  MAX_INTERVAL_MIN_WARNING: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0438\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B \u043C\u0430\u0454 \u0431\u0443\u0442\u0438 \u0449\u043E\u043D\u0430\u0439\u043C\u0435\u043D\u0448\u0435 1 \u0434\u0435\u043D\u044C.",
  MAX_LINK_CONTRIB: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0438\u0439 \u0432\u043D\u0435\u0441\u043E\u043A \u043F\u043E\u0441\u0438\u043B\u0430\u043D\u044C",
  MAX_LINK_CONTRIB_DESC: "\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0438\u0439 \u0432\u043D\u0435\u0441\u043E\u043A \u0437\u0432\u0430\u0436\u0435\u043D\u043E\u0457 \u043B\u0435\u0433\u043A\u043E\u0441\u0442\u0456 \u043F\u043E\u0432'\u044F\u0437\u0430\u043D\u0438\u0445 \u043D\u043E\u0442\u0430\u0442\u043E\u043A \u0443 \u043F\u043E\u0447\u0430\u0442\u043A\u043E\u0432\u0443 \u043B\u0435\u0433\u043A\u0456\u0441\u0442\u044C.",
  LOGGING: "\u0416\u0443\u0440\u043D\u0430\u043B\u044E\u0432\u0430\u043D\u043D\u044F",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\u041F\u043E\u043A\u0430\u0437\u0443\u0432\u0430\u0442\u0438 \u043D\u0430\u043B\u0430\u0433\u043E\u0434\u0436\u0443\u0432\u0430\u043B\u044C\u043D\u0443 \u0456\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0456\u044E \u043F\u043B\u0430\u043D\u0443\u0432\u0430\u043B\u044C\u043D\u0438\u043A\u0430 \u0432 \u043A\u043E\u043D\u0441\u043E\u043B\u0456 \u0440\u043E\u0437\u0440\u043E\u0431\u043D\u0438\u043A\u0430",
  DISPLAY_PARSER_DEBUG_INFO: "\u041F\u043E\u043A\u0430\u0437\u0443\u0432\u0430\u0442\u0438 \u043D\u0430\u043B\u0430\u0433\u043E\u0434\u0436\u0443\u0432\u0430\u043B\u044C\u043D\u0443 \u0456\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0456\u044E \u043F\u0430\u0440\u0441\u0435\u0440\u0430 \u0432 \u043A\u043E\u043D\u0441\u043E\u043B\u0456 \u0440\u043E\u0437\u0440\u043E\u0431\u043D\u0438\u043A\u0430",
  SCHEDULING: "\u041F\u043B\u0430\u043D\u0443\u0432\u0430\u043D\u043D\u044F",
  EXPERIMENTAL: "\u0415\u043A\u0441\u043F\u0435\u0440\u0438\u043C\u0435\u043D\u0442\u0430\u043B\u044C\u043D\u0435",
  HELP: "\u0414\u043E\u0432\u0456\u0434\u043A\u0430",
  STORE_IN_NOTES: "\u0423 \u043D\u043E\u0442\u0430\u0442\u043A\u0430\u0445",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\u0427\u0435\u0440\u0433\u0430 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043D\u043E\u0442\u0430\u0442\u043E\u043A",
  CLOSE: "\u0417\u0430\u043A\u0440\u0438\u0442\u0438",
  NEW: "\u041D\u043E\u0432\u0456",
  YESTERDAY: "\u0412\u0447\u043E\u0440\u0430",
  TODAY: "\u0421\u044C\u043E\u0433\u043E\u0434\u043D\u0456",
  TOMORROW: "\u0417\u0430\u0432\u0442\u0440\u0430",
  // stats-modal.tsx
  STATS_TITLE: "\u0421\u0442\u0430\u0442\u0438\u0441\u0442\u0438\u043A\u0430",
  MONTH: "\u041C\u0456\u0441\u044F\u0446\u044C",
  QUARTER: "\u041A\u0432\u0430\u0440\u0442\u0430\u043B",
  YEAR: "\u0420\u0456\u043A",
  LIFETIME: "\u0417\u0430 \u0432\u0435\u0441\u044C \u0447\u0430\u0441",
  FORECAST: "\u041F\u0440\u043E\u0433\u043D\u043E\u0437",
  FORECAST_DESC: "\u041A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044C \u043A\u0430\u0440\u0442\u043E\u043A, \u0449\u043E \u0431\u0443\u0434\u0443\u0442\u044C \u0434\u043E \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u0432 \u043C\u0430\u0439\u0431\u0443\u0442\u043D\u044C\u043E\u043C\u0443",
  SCHEDULED: "\u0417\u0430\u043F\u043B\u0430\u043D\u043E\u0432\u0430\u043D\u043E",
  DAYS: "\u0414\u043D\u0456",
  NUMBER_OF_CARDS: "\u041A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044C \u043A\u0430\u0440\u0442\u043E\u043A",
  REVIEWS_PER_DAY: "\u0421\u0435\u0440\u0435\u0434\u043D\u0454: ${avg} \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u044C/\u0434\u0435\u043D\u044C",
  INTERVALS: "\u0406\u043D\u0442\u0435\u0440\u0432\u0430\u043B\u0438",
  INTERVALS_DESC: "\u0417\u0430\u0442\u0440\u0438\u043C\u043A\u0438, \u043F\u0456\u0441\u043B\u044F \u044F\u043A\u0438\u0445 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u043D\u044F \u043F\u043E\u043A\u0430\u0437\u0443\u044E\u0442\u044C\u0441\u044F \u0437\u043D\u043E\u0432\u0443",
  COUNT: "\u041A\u0456\u043B\u044C\u043A\u0456\u0441\u0442\u044C",
  INTERVALS_SUMMARY: "\u0421\u0435\u0440\u0435\u0434\u043D\u0456\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B: ${avg}, \u043D\u0430\u0439\u0434\u043E\u0432\u0448\u0438\u0439 \u0456\u043D\u0442\u0435\u0440\u0432\u0430\u043B: ${longest}",
  EASES: "\u041A\u043E\u0435\u0444\u0456\u0446\u0456\u0454\u043D\u0442\u0438 \u043B\u0435\u0433\u043A\u043E\u0441\u0442\u0456",
  EASES_SUMMARY: "\u0421\u0435\u0440\u0435\u0434\u043D\u0456\u0439 \u043A\u043E\u0435\u0444\u0456\u0446\u0456\u0454\u043D\u0442 \u043B\u0435\u0433\u043A\u043E\u0441\u0442\u0456: ${avgEase}",
  EASE: "\u041B\u0435\u0433\u043A\u0456\u0441\u0442\u044C",
  CARD_TYPES: "\u0422\u0438\u043F\u0438 \u043A\u0430\u0440\u0442\u043E\u043A",
  CARD_TYPES_DESC: "\u0412\u043A\u043B\u044E\u0447\u0430\u0454 \u0442\u0430\u043A\u043E\u0436 \u0432\u0456\u0434\u043A\u043B\u0430\u0434\u0435\u043D\u0456 \u043A\u0430\u0440\u0442\u043A\u0438, \u044F\u043A\u0449\u043E \u0454",
  CARD_TYPE_NEW: "\u041D\u043E\u0432\u0456",
  CARD_TYPE_YOUNG: "\u041C\u043E\u043B\u043E\u0434\u0456",
  CARD_TYPE_MATURE: "\u0417\u0440\u0456\u043B\u0456",
  CARD_TYPES_SUMMARY: "\u0423\u0441\u044C\u043E\u0433\u043E \u043A\u0430\u0440\u0442\u043E\u043A: ${totalCardsCount}",
  SEARCH: "\u041F\u043E\u0448\u0443\u043A",
  PREVIOUS: "\u041F\u043E\u043F\u0435\u0440\u0435\u0434\u043D\u0456\u0439",
  NEXT: "\u041D\u0430\u0441\u0442\u0443\u043F\u043D\u0438\u0439",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var uk_default = uk;

// src/lang/locale/ur.ts
var ur = {
  ...en_default,
  language: "ur",
  languageName: "\u0627\u0631\u062F\u0648"
};
var ur_default = ur;

// src/lang/locale/vi.ts
var vi = {
  ...en_default,
  language: "vi",
  languageName: "Ti\u1EBFng Vi\u1EC7t"
};
var vi_default = vi;

// src/lang/locale/zh-cn.ts
var zhCN = {
  ...en_default,
  language: "zh-cn",
  languageName: "\u7B80\u4F53\u4E2D\u6587",
  // flashcard-modal.tsx
  DECKS: "\u5361\u7EC4",
  DUE_CARDS: "\u5230\u671F\u5361\u7247",
  NEW_CARDS: "\u65B0\u5361\u7247",
  TOTAL_CARDS: "\u5168\u90E8\u5361\u7247",
  BACK: "\u8FD4\u56DE",
  SKIP: "\u7565\u8FC7",
  EDIT_CARD: "\u7F16\u8F91\u5361\u7247",
  RESET_CARD_PROGRESS: "\u91CD\u7F6E\u5361\u7247",
  HARD: "\u8F83\u96BE",
  GOOD: "\u8BB0\u5F97",
  EASY: "\u7B80\u5355",
  SHOW_ANSWER: "\u663E\u793A\u7B54\u6848",
  CARD_PROGRESS_RESET: "\u5361\u7247\u5DF2\u88AB\u91CD\u7F6E\u3002",
  SAVE: "\u4FDD\u5B58",
  CANCEL: "\u53D6\u6D88",
  NO_INPUT: "\u6CA1\u6709\u63D0\u4F9B\u8F93\u5165\u3002",
  CURRENT_EASE_HELP_TEXT: "\u76EE\u524D\u638C\u63E1\u7A0B\u5EA6\uFF1A",
  CURRENT_INTERVAL_HELP_TEXT: "\u76EE\u524D\u95F4\u9694\uFF1A",
  CARD_GENERATED_FROM: "\u751F\u6210\u81EA\uFF1A${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\u6253\u5F00\u4E00\u4E2A\u7B14\u8BB0\u5F00\u59CB\u590D\u4E60",
  REVIEW_CARDS: "\u590D\u4E60\u5361\u7247",
  REVIEW_DIFFICULTY_FILE_MENU: "\u590D\u4E60\uFF1A${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "\u6807\u8BB0\u4E3A\u201C${difficulty}\u201D",
  REVIEW_ALL_CARDS: "\u590D\u4E60\u6240\u6709\u7B14\u8BB0\u4E2D\u7684\u5361\u7247",
  CRAM_ALL_CARDS: "\u9009\u62E9\u8981\u96C6\u4E2D\u590D\u4E60\u7684\u5361\u7EC4",
  REVIEW_CARDS_IN_NOTE: "\u590D\u4E60\u6B64\u7B14\u8BB0\u4E2D\u7684\u5361\u7247",
  CRAM_CARDS_IN_NOTE: "\u96C6\u4E2D\u590D\u4E60\u6B64\u7B14\u8BB0\u4E2D\u7684\u5361\u7247",
  VIEW_STATS: "\u67E5\u770B\u6570\u636E",
  OPEN_REVIEW_QUEUE_VIEW: "\u5728\u4FA7\u8FB9\u680F\u4E2D\u6253\u5F00\u7B14\u8BB0\u590D\u4E60\u961F\u5217",
  STATUS_BAR: "\u590D\u4E60: ${dueNotesCount} \u7B14\u8BB0, ${dueFlashcardsCount} \u5361\u7247\u5DF2\u5230\u671F",
  SYNC_TIME_TAKEN: "\u540C\u6B65\u65F6\u95F4 ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "\u7B14\u8BB0\u4FDD\u5B58\u5728\u5DF2\u88AB\u5FFD\u7565\u7684\u8DEF\u5F84\u4E2D\uFF08\u68C0\u67E5\u8BBE\u7F6E\u9009\u9879\uFF09\u3002",
  PLEASE_TAG_NOTE: "\u8BF7\u5C06\u9700\u8981\u590D\u4E60\u7684\u7B14\u8BB0\u4E2D\u52A0\u5165\u6B63\u786E\u7684\u6807\u7B7E\uFF08\u68C0\u67E5\u8BBE\u7F6E\u9009\u9879\uFF09\u3002",
  RESPONSE_RECEIVED: "\u53CD\u9988\u5DF2\u6536\u5230",
  NO_DECK_EXISTS: "\u6CA1\u6709 ${deckName} \u5361\u7EC4",
  ALL_CAUGHT_UP: "\u90FD\u590D\u4E60\u5B8C\u5566\uFF0C\u4F60\u771F\u68D2\uFF01",
  REVIEW_REMINDER_NOTICE: "\u95EA\u5361\u5DF2\u7ECF\u53EF\u4EE5\u590D\u4E60\u4E86\u3002\u56DE\u5230 Obsidian \u7EE7\u7EED\u5B66\u4E60\u3002",
  // scheduling.ts
  DAYS_STR_IVL: "${interval}\u5929",
  MONTHS_STR_IVL: "${interval}\u6708",
  YEARS_STR_IVL: "${interval}\u5E74",
  DAYS_STR_IVL_MOBILE: "${interval}\u5929",
  MONTHS_STR_IVL_MOBILE: "${interval}\u6708",
  YEARS_STR_IVL_MOBILE: "${interval}\u5E74",
  // settings.ts
  SETTINGS_HEADER: "\u95F4\u9694\u91CD\u590D\u63D2\u4EF6",
  GROUP_TAGS_FOLDERS: "\u6807\u7B7E\u548C\u6587\u4EF6\u5939",
  GROUP_FLASHCARD_REVIEW: "\u95EA\u5361\u590D\u4E60",
  GROUP_FLASHCARD_SEPARATORS: "\u95EA\u5B58\u5361\u5206\u9694\u7B26",
  GROUP_DATA_STORAGE: "\u5B58\u50A8\u8BA1\u5212\u6570\u636E",
  GROUP_DATA_STORAGE_DESC: "\u9009\u62E9\u5B58\u50A8\u8BA1\u5212\u6570\u636E\u4F4D\u7F6E",
  GROUP_FLASHCARDS_NOTES: "\u95EA\u5361\u548C\u7B14\u8BB0",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: '\u4E86\u89E3\u66F4\u591A, \u8BF7\u70B9\u51FB<a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "\u5FFD\u7565\u6B64\u6587\u4EF6\u5939",
  FOLDERS_TO_IGNORE_DESC: "\u5728\u5355\u72EC\u4E00\u884C\u4E2D\u8F93\u5165\u6587\u4EF6\u5939\u8DEF\u5F84\u6216\u5168\u5C40\u6A21\u5F0F\uFF0C\u4F8B\u5982 Templates/Scripts \u6216 .excalidraw.md\u3002\u6B64\u8BBE\u7F6E\u5BF9\u95EA\u5B58\u5361\u548C\u7B14\u8BB0\u90FD\u901A\u7528\u3002",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "\u5361\u7247",
  FLASHCARD_EASY_LABEL: "\u201C\u7B80\u5355\u201D\u6309\u94AE\u6587\u672C",
  FLASHCARD_GOOD_LABEL: "\u201C\u8BB0\u5F97\u201D\u6309\u94AE\u6587\u672C",
  FLASHCARD_HARD_LABEL: "\u201C\u8F83\u96BE\u201D\u6309\u94AE\u6587\u672C",
  FLASHCARD_EASY_DESC: "\u81EA\u5B9A\u4E49\u201C\u7B80\u5355\u201D\u6309\u94AE\u7684\u6807\u7B7E",
  FLASHCARD_GOOD_DESC: "\u81EA\u5B9A\u4E49\u201C\u8BB0\u5F97\u201D\u6309\u94AE\u7684\u6807\u7B7E",
  FLASHCARD_HARD_DESC: "\u81EA\u5B9A\u4E49\u201C\u8F83\u96BE\u201D\u6309\u94AE\u7684\u6807\u7B7E",
  REVIEW_BUTTON_DELAY: "\u6309\u94AE\u6309\u4E0B\u5EF6\u8FDF\uFF08\u6BEB\u79D2\uFF09",
  REVIEW_BUTTON_DELAY_DESC: "\u5728\u518D\u6B21\u6309\u4E0B\u590D\u4E60\u6309\u94AE\u524D\u589E\u52A0\u5EF6\u8FDF\u3002",
  FLASHCARD_TAGS: "\u5361\u7247\u6807\u7B7E",
  FLASHCARD_TAGS_DESC: "\u8F93\u5165\u6807\u7B7E\uFF0C\u7528\u7A7A\u683C\u6216\u65B0\u5EFA\u884C\u5206\u9694\uFF0C\u4F8B\u5982\uFF1A#flashcards #deck2 #deck3.",
  CONVERT_FOLDERS_TO_DECKS: "\u5C06\u6587\u4EF6\u5939\u5185\u5BB9\u8F6C\u6362\u4E3A\u5361\u7247\u7EC4\u548C\u5B50\u5361\u7247\u7EC4",
  CONVERT_FOLDERS_TO_DECKS_DESC: "\u6B64\u9009\u9879\u4E3A\u5361\u7247\u6807\u7B7E\u9009\u9879\u7684\u66FF\u4EE3\u9009\u9879\u3002",
  INLINE_SCHEDULING_COMMENTS: "\u5C06\u8BA1\u5212\u91CD\u590D\u65E5\u671F\u4FDD\u5B58\u5728\u5361\u7247\u6700\u540E\u4E00\u884C\u7684\u540C\u4E00\u884C",
  INLINE_SCHEDULING_COMMENTS_DESC: "HTML\u6CE8\u91CA\u4E0D\u518D\u7834\u574F\u5217\u8868\u683C\u5F0F",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\u5C06\u5173\u8054\u5361\u7247\u9690\u85CF\u81F3\u4E0B\u4E00\u5929",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "\u5173\u8054\u5361\u7247\u662F\u6765\u81EA\u540C\u4E00\u5361\u7247\u7684\u4E0D\u540C\u5F62\u5F0F\uFF0C \u4F8B\u5982\uFF1A\u5B8C\u5F62\u586B\u7A7A\u5361\u7247",
  SHOW_CARD_CONTEXT: "\u5728\u5361\u7247\u4E2D\u663E\u793A\u4E0A\u4E0B\u6587",
  SHOW_CARD_CONTEXT_DESC: "\u4F8B\u5982\uFF1A\u6807\u9898 > \u526F\u6807\u9898 > \u5C0F\u6807\u9898 > ... > \u5C0F\u6807\u9898",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "\u5C06\u4E0B\u6B21\u590D\u4E60\u65F6\u95F4\u663E\u793A\u5728\u590D\u4E60\u6309\u94AE",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "\u4E86\u89E3\u4F60\u7684\u5361\u7247\u88AB\u63A8\u8FDF\u4E86\u591A\u4E45\u5BF9\u4F60\u5F88\u6709\u7528",
  CARD_MODAL_HEIGHT_PERCENT: "\u5361\u7247\u9AD8\u5EA6\u767E\u5206\u6BD4",
  CARD_MODAL_SIZE_PERCENT_DESC: "\u8BF7\u5728\u79FB\u52A8\u7AEF\u4F7F\u7528\u5E76\u9700\u8981\u6D4F\u89C8\u8F83\u5927\u56FE\u7247\u65F6\u8BBE\u4E3A100%",
  RESET_DEFAULT: "\u91CD\u7F6E\u4E3A\u9ED8\u8BA4",
  CARD_MODAL_WIDTH_PERCENT: "\u5361\u7247\u5BBD\u5EA6\u767E\u5206\u6BD4",
  RANDOMIZE_CARD_ORDER: "\u590D\u4E60\u65F6\u968F\u673A\u663E\u793A\u5361\u7247\uFF1F",
  REVIEW_CARD_ORDER_WITHIN_DECK: "\u590D\u4E60\u65F6\u5361\u7247\u7EC4\u5185\u7684\u5361\u7247\u6392\u5E8F",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "\u5361\u7247\u7EC4\u5185\u987A\u5E8F (\u5168\u90E8\u65B0\u5361\u7247\u4F18\u5148)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "\u5361\u7247\u7EC4\u5185\u987A\u5E8F (\u5168\u90E8\u5230\u671F\u5361\u7247\u4F18\u5148)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "\u5361\u7247\u7EC4\u5185\u4E71\u5E8F (\u5168\u90E8\u65B0\u5361\u7247\u4F18\u5148)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "\u5361\u7247\u7EC4\u5185\u4E71\u5E8F (\u5168\u90E8\u5230\u671F\u5361\u7247\u4F18\u5148)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "\u5361\u7247\u7EC4\u53CA\u5361\u7247\u90FD\u4E71\u5E8F",
  REVIEW_DECK_ORDER: "\u590D\u4E60\u65F6\u5361\u7247\u7EC4\u7684\u6392\u5E8F",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "\u987A\u5E8F (\u5728\u524D\u4E00\u5361\u7247\u7EC4\u5185\u5361\u7247\u90FD\u590D\u4E60\u5B8C\u540E)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "\u4E71\u5E8F (\u5728\u524D\u4E00\u5361\u7247\u7EC4\u5185\u5361\u7247\u90FD\u590D\u4E60\u5B8C\u540E)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "\u5361\u7247\u7EC4\u53CA\u5361\u7247\u90FD\u4E71\u5E8F",
  REVIEW_REMINDERS: "\u590D\u4E60\u63D0\u9192",
  REVIEW_REMINDERS_DESC: "\u5B9A\u671F\u68C0\u67E5\u662F\u5426\u6709\u65B0\u7684\u6216\u5230\u671F\u7684\u95EA\u5361\uFF0C\u5E76\u5728\u53EF\u4EE5\u590D\u4E60\u65F6\u63D0\u9192\u4F60\u3002",
  REVIEW_REMINDER_CHECK_ON_STARTUP: "\u542F\u52A8\u540E\u7ACB\u5373\u68C0\u67E5",
  REVIEW_REMINDER_CHECK_ON_STARTUP_DESC: "\u5728 Obsidian \u5E03\u5C40\u5C31\u7EEA\u540E\u7ACB\u5373\u6267\u884C\u4E00\u6B21\u68C0\u67E5\uFF0C\u4E0D\u7B49\u5F85\u9996\u6B21\u5468\u671F\u89E6\u53D1\u3002",
  REVIEW_REMINDER_INTERVAL: "\u63D0\u9192\u95F4\u9694\uFF08\u5206\u949F\uFF09",
  REVIEW_REMINDER_INTERVAL_DESC: "\u6BCF N \u5206\u949F\u68C0\u67E5\u4E00\u6B21\u3002\u6700\u5C0F 1 \u5206\u949F\uFF0C\u6700\u5927 1440 \u5206\u949F\u3002",
  REVIEW_REMINDER_INTERVAL_MIN_WARNING: "\u63D0\u9192\u95F4\u9694\u5FC5\u987B\u662F 1 \u5230 1440 \u4E4B\u95F4\u7684\u6570\u5B57\u3002",
  REVIEW_REMINDER_MESSAGE: "\u63D0\u9192\u6D88\u606F",
  REVIEW_REMINDER_MESSAGE_DESC: "\u53EF\u9009\u7684\u81EA\u5B9A\u4E49\u63D0\u9192\u6587\u6848\u3002\u7559\u7A7A\u65F6\u4F7F\u7528\u9ED8\u8BA4\u6D88\u606F\u3002",
  REVIEW_REMINDER_AUTO_OPEN: "\u81EA\u52A8\u6253\u5F00\u590D\u4E60",
  REVIEW_REMINDER_AUTO_OPEN_DESC: "\u542F\u7528\u540E\uFF0C\u63D0\u9192\u89E6\u53D1\u65F6\u4F1A\u76F4\u63A5\u6253\u5F00\u73B0\u6709\u7684\u95EA\u5361\u590D\u4E60\u754C\u9762\u3002",
  REVIEW_REMINDER_SHOW_NOTICE: "\u63D0\u9192\u65F6\u663E\u793A\u901A\u77E5",
  REVIEW_REMINDER_SHOW_NOTICE_DESC: "\u63D0\u9192\u89E6\u53D1\u65F6\u663E\u793A\u4E00\u4E2A\u4E34\u65F6\u901A\u77E5\u3002",
  REVIEW_REMINDER_PLAY_SOUND: "\u63D0\u9192\u65F6\u64AD\u653E\u58F0\u97F3",
  REVIEW_REMINDER_PLAY_SOUND_DESC: "\u63D0\u9192\u89E6\u53D1\u65F6\u64AD\u653E\u4E00\u6BB5\u7B80\u77ED\u63D0\u793A\u97F3\u3002",
  REVIEW_REMINDER_BOUNCE_DOCK: "\u63D0\u9192\u65F6\u5F39\u8DF3 Dock \u56FE\u6807",
  REVIEW_REMINDER_BOUNCE_DOCK_DESC: "\u5728\u684C\u9762\u7AEF\uFF0C\u63D0\u9192\u89E6\u53D1\u65F6\u5F39\u8DF3 Dock \u56FE\u6807\u3002",
  DISABLE_CLOZE_CARDS: "\u4E0D\u8FDB\u884C\u5B8C\u5F62\u586B\u7A7A",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "\u5C06 ==\u9AD8\u4EAE== \u8F6C\u6362\u4E3A\u5B8C\u5F62\u586B\u7A7A",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: '\u6DFB\u52A0/\u5220\u9664 "\u5B8C\u5F62\u586B\u7A7A\u6A21\u5F0F" \u4E2D\u7684 <code>${defaultPattern}</code>',
  CONVERT_BOLD_TEXT_TO_CLOZES: "\u5C06 **\u7C97\u4F53** \u8F6C\u6362\u4E3A\u5B8C\u5F62\u586B\u7A7A",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: '\u6DFB\u52A0/\u5220\u9664 "\u5B8C\u5F62\u586B\u7A7A\u6A21\u5F0F" \u4E2D\u7684 <code>${defaultPattern}</code>',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "\u5C06 {{\u5927\u62EC\u53F7}} \u8F6C\u6362\u4E3A\u5B8C\u5F62\u586B\u7A7A",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: '\u6DFB\u52A0/\u5220\u9664 "\u5B8C\u5F62\u586B\u7A7A\u6A21\u5F0F" \u4E2D\u7684 <code>${defaultPattern}</code>',
  CLOZE_PATTERNS: "\u5B8C\u5F62\u586B\u7A7A\u6A21\u5F0F",
  CLOZE_PATTERNS_DESC: '\u8F93\u5165\u4EE5\u6362\u884C\u7B26\u5206\u9694\u7684\u5B8C\u5F62\u586B\u7A7A\u6A21\u5F0F. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "\u5355\u884C\u5361\u7247\u7684\u5206\u9694\u7B26",
  FIX_SEPARATORS_MANUALLY_WARNING: "\u6CE8\u610F\uFF1A\u66F4\u6539\u6B64\u9009\u9879\u540E\u4F60\u5C06\u9700\u8981\u81EA\u884C\u66F4\u6539\u5DF2\u5B58\u5728\u5361\u7247\u7684\u5206\u9694\u7B26\u3002",
  INLINE_REVERSED_CARDS_SEPARATOR: "\u5355\u884C\u7FFB\u8F6C\u5361\u7247\u7684\u5206\u9694\u7B26",
  MULTILINE_CARDS_SEPARATOR: "\u591A\u884C\u5361\u7247\u7684\u5206\u9694\u7B26",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\u591A\u884C\u7FFB\u8F6C\u5361\u7247\u7684\u5206\u9694\u7B26",
  MULTILINE_CARDS_END_MARKER: "\u8868\u793A\u586B\u7A7A\u548C\u591A\u884C\u95EA\u5361\u7ED3\u675F\u7684\u5B57\u7B26",
  NOTES: "\u7B14\u8BB0",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "\u542F\u52A8\u65F6\u5F00\u542F\u7B14\u8BB0\u590D\u4E60\u7A97\u683C",
  TAGS_TO_REVIEW: "\u590D\u4E60\u6807\u7B7E",
  TAGS_TO_REVIEW_DESC: "\u8F93\u5165\u6807\u7B7E\uFF0C\u7528\u7A7A\u683C\u6216\u65B0\u5EFA\u884C\u5206\u9694\uFF0C\u4F8B\u5982\uFF1A#review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "\u590D\u4E60\u968F\u673A\u7B14\u8BB0",
  OPEN_RANDOM_NOTE_DESC: "\u5173\u95ED\u6B64\u9009\u9879\uFF0C\u7B14\u8BB0\u5C06\u4EE5\u91CD\u8981\u5EA6(PageRank)\u6392\u5E8F\u3002",
  AUTO_NEXT_NOTE: "\u590D\u4E60\u540E\u81EA\u52A8\u6253\u5F00\u4E0B\u4E00\u4E2A\u7B14\u8BB0",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\u8BF7\u5728\u6587\u4EF6\u83DC\u5355\u4E2D\u542F\u7528\u590D\u4E60\u9009\u9879\uFF08\u4F8B\u5982\uFF1A\u590D\u4E60\uFF1A\u7B80\u5355\u3001\u826F\u597D\u3001\u56F0\u96BE",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\u5982\u679C\u60A8\u5728\u6587\u4EF6\u83DC\u5355\u4E2D\u7981\u7528\u590D\u4E60\u9009\u9879\uFF0C\u60A8\u53EF\u4EE5\u4F7F\u7528\u63D2\u4EF6\u547D\u4EE4\u6765\u590D\u4E60\u7B14\u8BB0\uFF0C\u5982\u679C\u60A8\u5B9A\u4E49\u4E86\u76F8\u5173\u5FEB\u6377\u952E\uFF0C\u4E5F\u53EF\u4EE5\u4F7F\u7528\u5B83\u4EEC\u3002",
  MAX_N_DAYS_REVIEW_QUEUE: "\u53F3\u8FB9\u680F\u4E2D\u663E\u793A\u7684\u6700\u5927\u5929\u6570",
  MIN_ONE_DAY: "\u5929\u6570\u6700\u5C0F\u503C\u4E3A1",
  VALID_NUMBER_WARNING: "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u6570\u5B57\u3002",
  UI: "User Interface",
  OPEN_IN_TAB: "\u5728\u65B0\u6807\u7B7E\u6253\u5F00",
  OPEN_IN_TAB_DESC: "\u5173\u95ED\u6B64\u9009\u9879\u53EF\u5728\u6A21\u5F0F\u7A97\u53E3\u4E2D\u6253\u5F00\u63D2\u4EF6",
  SHOW_STATUS_BAR: "\u663E\u793A\u5728\u72B6\u6001\u680F",
  SHOW_STATUS_BAR_DESC: "\u5C06\u6B64\u5173\u95ED\u4EE5\u9690\u85CF Obsidian \u72B6\u6001\u680F\u4E2D\u7684\u5361\u7247\u590D\u4E60\u72B6\u6001\u3002",
  SHOW_RIBBON_ICON: "\u5728\u529F\u80FD\u533A\u4E2D\u663E\u793A\u56FE\u6807",
  SHOW_RIBBON_ICON_DESC: "\u5173\u95ED\u6B64\u9009\u9879\u53EF\u9690\u85CF Obsidian \u529F\u80FD\u533A\u680F\u4E2D\u7684\u63D2\u4EF6\u56FE\u6807",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\u9ED8\u8BA4\u5728\u5217\u8868\u4E2D\u5C55\u5F00\u5D4C\u5957\u5B50\u724C\u7EC4",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "\u5173\u95ED\u6B64\u9009\u9879\u53EF\u6298\u53E0\u540C\u4E00\u5F20\u5361\u7247\u4E2D\u7684\u5D4C\u5957\u724C\u7EC4\u3002\u5982\u679C\u60A8\u7684\u5361\u7247\u5C5E\u4E8E\u540C\u4E00\u6587\u4EF6\u4E2D\u7684\u8BB8\u591A\u5957\u724C\uFF0C\u5219\u5F88\u6709\u7528\u3002",
  ALGORITHM: "\u7B97\u6CD5",
  CHECK_ALGORITHM_WIKI: '\u4E86\u89E3\u66F4\u591A, \u8BF7\u70B9\u51FB<a href="${algoUrl}">\u7B97\u6CD5\u5B9E\u73B0</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "\u57FA\u7840\u638C\u63E1\u7A0B\u5EA6",
  BASE_EASE_DESC: "\u6700\u5C0F\u503C130\uFF0C\u63A8\u8350\u503C\u7EA6250.",
  BASE_EASE_MIN_WARNING: "\u57FA\u7840\u638C\u63E1\u7A0B\u5EA6\u7684\u6700\u5C0F\u503C\u4E3A130\u3002",
  LAPSE_INTERVAL_CHANGE: "\u5C06\u590D\u4E60\u65F6\u6807\u6CE8\u4E3A\u201C\u8F83\u96BE\u201D\u7684\u5361\u7247\u6216\u7B14\u8BB0\u590D\u4E60\u95F4\u9694\u7F29\u77ED",
  LAPSE_INTERVAL_CHANGE_DESC: "\u65B0\u590D\u4E60\u95F4\u9694 = \u539F\u590D\u4E60\u95F4\u9694 * \u95F4\u9694\u6539\u53D8\u7CFB\u6570 / 100.",
  EASY_BONUS: "\u7B80\u5355\u5956\u52B1",
  EASY_BONUS_DESC: "\u7B80\u5355\u5956\u52B1\u8BBE\u5B9A\u201C\u8BB0\u5F97\u201D\u548C\u201C\u7B80\u5355\u201D\u5361\u7247\u6216\u7B14\u8BB0\u7684\u590D\u4E60\u95F4\u9694\u5DEE\u8DDD\uFF08\u6700\u5C0F\u503C100%\uFF09\u3002",
  EASY_BONUS_MIN_WARNING: "\u7B80\u5355\u5956\u52B1\u81F3\u5C11\u4E3A100\u3002",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "\u6700\u5927\u95F4\u9694\uFF08\u5929\uFF09",
  MAX_INTERVAL_DESC: "\u8BBE\u5B9A\u590D\u4E60\u7684\u6700\u5927\u95F4\u9694\u65F6\u95F4\uFF08\u9ED8\u8BA4\u503C100\u5E74\uFF09\u3002",
  MAX_INTERVAL_MIN_WARNING: "\u6700\u5927\u95F4\u9694\u81F3\u5C11\u4E3A1\u5929",
  MAX_LINK_CONTRIB: "\u6700\u5927\u94FE\u63A5\u6536\u76CA",
  MAX_LINK_CONTRIB_DESC: "\u94FE\u63A5\u7B14\u8BB0\u7684\u52A0\u6743\u638C\u63E1\u7A0B\u5EA6\u5BF9\u539F\u59CB\u638C\u63E1\u7A0B\u5EA6\u7684\u6700\u5927\u8D21\u732E\u3002",
  LOGGING: "\u8BB0\u5F55\u4E2D",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\u5728\u5F00\u53D1\u8005\u63A7\u5236\u53F0\u4E2D\u663E\u793A\u8C03\u8BD5\u4FE1\u606F",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\u7B14\u8BB0\u590D\u4E60\u5E8F\u5217",
  CLOSE: "\u4E34\u8FD1",
  NEW: "\u65B0",
  YESTERDAY: "\u6628\u5929",
  TODAY: "\u4ECA\u5929",
  TOMORROW: "\u660E\u5929",
  // stats-modal.tsx
  STATS_TITLE: "\u6570\u636E",
  MONTH: "\u6708",
  QUARTER: "\u5B63",
  YEAR: "\u5E74",
  LIFETIME: "\u5168\u90E8",
  FORECAST: "\u9884\u671F",
  FORECAST_DESC: "\u5C06\u8981\u5230\u671F\u7684\u5361\u7247\u6570\u91CF",
  SCHEDULED: "\u5DF2\u6392\u671F",
  DAYS: "\u5929",
  NUMBER_OF_CARDS: "\u5361\u7247\u6570\u91CF",
  REVIEWS_PER_DAY: "\u5E73\u5747: \u590D\u4E60${avg} /\u5929",
  INTERVALS: "\u95F4\u9694",
  INTERVALS_DESC: "\u5230\u4E0B\u4E00\u6B21\u590D\u4E60\u7684\u65F6\u95F4\u95F4\u9694",
  COUNT: "\u8BA1\u6570",
  INTERVALS_SUMMARY: "\u5E73\u5747\u95F4\u9694\u65F6\u95F4: ${avg}, \u6700\u957F\u95F4\u9694\u65F6\u95F4: ${longest}",
  EASES: "\u638C\u63E1\u7A0B\u5EA6",
  EASES_SUMMARY: "\u5E73\u5747\u638C\u63E1\u7A0B\u5EA6: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "\u5361\u7247\u7C7B\u578B",
  CARD_TYPES_DESC: "\u5982\u6709\uFF0C\u5C06\u663E\u793A\u9690\u85CF\u7684\u5361\u7247",
  CARD_TYPE_NEW: "\u65B0",
  CARD_TYPE_YOUNG: "\u8F83\u65B0",
  CARD_TYPE_MATURE: "\u719F\u6089",
  CARD_TYPES_SUMMARY: "\u603B\u5361\u7247\u6570: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var zh_cn_default = zhCN;

// src/lang/locale/zh-tw.ts
var zhTW = {
  ...en_default,
  language: "zh-tw",
  languageName: "\u7E41\u9AD4\u4E2D\u6587",
  // flashcard-modal.tsx
  DECKS: "\u724C\u7D44",
  DUE_CARDS: "\u5230\u671F\u5361\u7247",
  NEW_CARDS: "\u65B0\u5361\u7247",
  TOTAL_CARDS: "\u5168\u90E8\u5361\u7247",
  BACK: "\u8FD4\u56DE",
  SKIP: "\u7565\u904E",
  EDIT_CARD: "\u7DE8\u8F2F\u5361\u7247",
  RESET_CARD_PROGRESS: "\u91CD\u7F6E\u5361\u7247",
  HARD: "\u8F03\u96E3",
  GOOD: "\u8A18\u5F97",
  EASY: "\u7C21\u55AE",
  SHOW_ANSWER: "\u986F\u793A\u7B54\u6848",
  CARD_PROGRESS_RESET: "\u5361\u7247\u5DF2\u88AB\u91CD\u7F6E\u3002",
  SAVE: "\u5132\u5B58",
  CANCEL: "\u53D6\u6D88",
  NO_INPUT: "\u6C92\u6709\u63D0\u4F9B\u8F38\u5165\u3002",
  CURRENT_EASE_HELP_TEXT: "\u76EE\u524D\u638C\u63E1\u7A0B\u5EA6\uFF1A",
  CURRENT_INTERVAL_HELP_TEXT: "\u76EE\u524D\u9593\u9694\u6642\u9593\uFF1A",
  CARD_GENERATED_FROM: "\u751F\u6210\u81EA\uFF1A${notePath}",
  VIEW_CARD_INFO: "View Card Info",
  // main.ts
  OPEN_NOTE_FOR_REVIEW: "\u6253\u958B\u4E00\u500B\u7B46\u8A18\u958B\u59CB\u5FA9\u7FD2",
  REVIEW_CARDS: "\u5FA9\u7FD2\u5361\u7247",
  REVIEW_DIFFICULTY_FILE_MENU: "\u5FA9\u7FD2\uFF1A${difficulty}",
  REVIEW_NOTE_DIFFICULTY_CMD: "\u6A19\u8A18\u70BA\u300C${difficulty}\u300D",
  REVIEW_CARDS_IN_NOTE: "\u5FA9\u7FD2\u6B64\u7B46\u8A18\u4E2D\u7684\u5361\u7247",
  CRAM_ALL_CARDS: "\u9078\u64C7\u8981\u4E0D\u8A08\u96E3\u6613\u5EA6\u5FA9\u7FD2\u7684\u724C\u7D44",
  REVIEW_ALL_CARDS: "\u5FA9\u7FD2\u6240\u6709\u7B46\u8A18\u4E2D\u7684\u5361\u7247",
  CRAM_CARDS_IN_NOTE: "\u4E0D\u8A08\u96E3\u6613\u5EA6\u5FA9\u7FD2\u6B64\u7B46\u8A18\u4E2D\u7684\u5361\u7247",
  VIEW_STATS: "\u6AA2\u8996\u6578\u64DA",
  OPEN_REVIEW_QUEUE_VIEW: "Open Notes Review Queue in sidebar",
  STATUS_BAR: "\u5FA9\u7FD2: ${dueNotesCount} \u7B46\u8A18, ${dueFlashcardsCount} \u5361\u7247\u5DF2\u5230\u671F",
  SYNC_TIME_TAKEN: "\u540C\u6B65\u6642\u9593 ${t}ms",
  NOTE_IN_IGNORED_FOLDER: "\u7B46\u8A18\u5132\u5B58\u5728\u5DF2\u88AB\u5FFD\u7565\u7684\u8DEF\u5F91\u4E2D\uFF08\u6AA2\u67E5\u8A2D\u5B9A\u9078\u9805\uFF09\u3002",
  PLEASE_TAG_NOTE: "\u8ACB\u5C07\u9700\u8981\u5FA9\u7FD2\u7684\u7B46\u8A18\u4E2D\u52A0\u5165\u6B63\u78BA\u7684\u6A19\u7C64\uFF08\u6AA2\u67E5\u8A2D\u5B9A\u9078\u9805\uFF09\u3002",
  RESPONSE_RECEIVED: "\u56DE\u994B\u5DF2\u6536\u5230",
  NO_DECK_EXISTS: "\u6C92\u6709 ${deckName} \u724C\u7D44",
  ALL_CAUGHT_UP: "\u90FD\u5FA9\u7FD2\u5B8C\u5566\uFF0C\u4F60\u771F\u68D2\uFF01",
  // scheduling.ts
  DAYS_STR_IVL: "${interval}\u5929",
  MONTHS_STR_IVL: "${interval}\u6708",
  YEARS_STR_IVL: "${interval}\u5E74",
  DAYS_STR_IVL_MOBILE: "${interval}\u5929",
  MONTHS_STR_IVL_MOBILE: "${interval}\u6708",
  YEARS_STR_IVL_MOBILE: "${interval}\u5E74",
  // settings.ts
  SETTINGS_HEADER: "\u9593\u9694\u91CD\u8907\u5916\u639B",
  GROUP_TAGS_FOLDERS: "Tags & Folders",
  GROUP_FLASHCARD_REVIEW: "Flashcard Review",
  GROUP_FLASHCARD_SEPARATORS: "Flashcard Separators",
  GROUP_DATA_STORAGE: "Storage of Scheduling Data",
  GROUP_DATA_STORAGE_DESC: "Choose where to store the scheduling data",
  GROUP_FLASHCARDS_NOTES: "Flashcards & Notes",
  GROUP_CONTRIBUTING: "Contributing",
  CHECK_WIKI: '\u77AD\u89E3\u66F4\u591A, \u8ACB\u9EDE\u9078<a href="${wikiUrl}">wiki</a>.',
  GITHUB_DISCUSSIONS: 'Visit the <a href="${discussionsUrl}">discussions</a> section for Q&A help, feedback, and general discussion.',
  GITHUB_ISSUES: 'Raise an issue <a href="${issuesUrl}">here</a> if you have a feature request or a bug report.',
  GITHUB_SOURCE_CODE: 'The project\'s source code is available on <a href="${githubProjectUrl}">GitHub</a>.',
  CODE_CONTRIBUTION_INFO: '<a href="${codeContributionUrl}">Here\'s</a> how to contribute code to the plugin.',
  TRANSLATION_CONTRIBUTION_INFO: '<a href="${translationContributionUrl}">Here\'s</a> how to translate the plugin to another language.',
  FOLDERS_TO_IGNORE: "\u5FFD\u7565\u6B64\u8CC7\u6599\u593E",
  FOLDERS_TO_IGNORE_DESC: "Enter folder paths or glob patterns on separate lines e.g. Templates/Scripts or **/*.excalidraw.md. This setting is common to both flashcards and notes.",
  OBSIDIAN_INTEGRATION: "Integration into Obsidian",
  FLASHCARDS: "\u5361\u7247",
  FLASHCARD_EASY_LABEL: "\u7C21\u55AE\u6309\u9215\u6587\u5B57",
  FLASHCARD_GOOD_LABEL: "\u8A18\u5F97\u6309\u9215\u6587\u5B57",
  FLASHCARD_HARD_LABEL: "\u8F03\u96E3\u6309\u9215\u6587\u5B57",
  FLASHCARD_EASY_DESC: "\u81EA\u8A02\u300C\u7C21\u55AE\u300D\u6309\u9215\u7684\u6A19\u7C64",
  FLASHCARD_GOOD_DESC: "\u81EA\u8A02\u300C\u8A18\u5F97\u300D\u6309\u9215\u7684\u6A19\u7C64",
  FLASHCARD_HARD_DESC: "\u81EA\u8A02\u300C\u8F03\u96E3\u300D\u6309\u9215\u7684\u6A19\u7C64",
  REVIEW_BUTTON_DELAY: "Button Press Delay (ms)",
  REVIEW_BUTTON_DELAY_DESC: "Add a delay to the review buttons before they can be pressed again.",
  FLASHCARD_TAGS: "\u5361\u7247\u6A19\u7C64",
  FLASHCARD_TAGS_DESC: "\u8F38\u5165\u6A19\u7C64\uFF08\u7528\u7A7A\u767D\u6216\u63DB\u884C\u5B57\u5143\u5206\u9694\uFF09\uFF0C\u4F8B\u5982\uFF1A#flashcards #deck2 #deck3.",
  CONVERT_FOLDERS_TO_DECKS: "\u662F\u5426\u5C07\u8CC7\u6599\u593E\u5167\u5BB9\u8F49\u63DB\u70BA\u724C\u7D44\u548C\u5B50\u724C\u7D44\uFF1F",
  CONVERT_FOLDERS_TO_DECKS_DESC: "\u6B64\u9078\u9805\u70BA\u5361\u7247\u6A19\u7C64\u9078\u9805\u7684\u66FF\u4EE3\u9078\u9805\u3002",
  INLINE_SCHEDULING_COMMENTS: "\u662F\u5426\u5C07\u8A08\u5283\u91CD\u8907\u6642\u9593\u5132\u5B58\u5728\u5361\u7247\u6700\u5F8C\u4E00\u884C\u7684\u540C\u4E00\u884C\uFF1F",
  INLINE_SCHEDULING_COMMENTS_DESC: "\u52FE\u9078\u5F8CHTML\u8A3B\u89E3\u4E0D\u6703\u7834\u58DE\u5217\u8868\u683C\u5F0F\u554F\u984C\u3002",
  BURY_SIBLINGS_TILL_NEXT_DAY: "\u5C07\u53CD\u8F49\u5361\u7247\u96B1\u85CF\u81F3\u4E0B\u4E00\u5929\uFF1F",
  BURY_SIBLINGS_TILL_NEXT_DAY_DESC: "\u53CD\u8F49\u5361\u7247\u7531\u540C\u4E00\u5361\u7247\u6587\u5B57\u7522\u751F\uFF0C\u4F8B\u5982\uFF1A\u586B\u7A7A\u514B\u6F0F\u5B57",
  SHOW_CARD_CONTEXT: "\u5728\u5361\u7247\u4E2D\u986F\u793A\u4E0A\u4E0B\u6587\uFF1F",
  SHOW_CARD_CONTEXT_DESC: "\u4F8B\u5982\uFF1A\u6A19\u984C > \u526F\u6A19\u984C > \u5C0F\u6A19\u984C > ... > \u5C0F\u6A19\u984C",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS: "Show next review time in the review buttons",
  SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC: "Useful to know how far in the future your cards are being pushed.",
  CARD_MODAL_HEIGHT_PERCENT: "\u5361\u7247\u9AD8\u5EA6\u767E\u5206\u6BD4",
  CARD_MODAL_SIZE_PERCENT_DESC: "\u5728\u79FB\u52D5\u7AEF\u6216\u9700\u8981\u8F03\u5927\u5716\u7247\u6642\u61C9\u8A2D\u5B9A\u70BA100%",
  RESET_DEFAULT: "\u91CD\u7F6E\u70BA\u9810\u8A2D\u503C",
  CARD_MODAL_WIDTH_PERCENT: "\u5361\u7247\u5BEC\u5EA6\u767E\u5206\u6BD4",
  RANDOMIZE_CARD_ORDER: "\u5FA9\u7FD2\u6642\u96A8\u6A5F\u986F\u793A\u5361\u7247\uFF1F",
  REVIEW_CARD_ORDER_WITHIN_DECK: "\u5FA9\u7FD2\u6642\u724C\u7D44\u5167\u7684\u5361\u7247\u6392\u5E8F",
  REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL: "\u724C\u7D44\u5167\u9806\u5E8F (\u5168\u90E8\u65B0\u5361\u7247\u512A\u5148)",
  REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL: "\u724C\u7D44\u5167\u9806\u5E8F (\u5168\u90E8\u5230\u671F\u5361\u7247\u512A\u5148)",
  REVIEW_CARD_ORDER_NEW_FIRST_RANDOM: "\u724C\u7D44\u5167\u4E82\u5E8F (\u5168\u90E8\u65B0\u5361\u7247\u512A\u5148)",
  REVIEW_CARD_ORDER_DUE_FIRST_RANDOM: "\u724C\u7D44\u5167\u4E82\u5E8F (\u5168\u90E8\u5230\u671F\u5361\u7247\u512A\u5148)",
  REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD: "\u724C\u7D44\u53CA\u5361\u7247\u90FD\u4E82\u5E8F",
  REVIEW_DECK_ORDER: "\u5FA9\u7FD2\u6642\u724C\u7D44\u7684\u6392\u5E8F",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL: "\u9806\u5E8F (\u5728\u524D\u4E00\u724C\u7D44\u5167\u5361\u7247\u90FD\u5FA9\u7FD2\u5B8C\u5F8C)",
  REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM: "\u4E82\u5E8F (\u5728\u524D\u4E00\u724C\u7D44\u5167\u5361\u7247\u90FD\u5FA9\u7FD2\u5B8C\u5F8C)",
  REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD: "\u724C\u7D44\u53CA\u5361\u7247\u90FD\u4E82\u5E8F",
  DISABLE_CLOZE_CARDS: "\u505C\u7528\u586B\u7A7A\u514B\u6F0F\u5B57\u5361\u7247\uFF1F",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS: "Convert cloze patterns to input fields",
  CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC: "Replace cloze patterns with input fields when reviewing cloze cards.",
  CONVERT_HIGHLIGHTS_TO_CLOZES: "\u5C07 ==\u9AD8\u4EAE== \u8F49\u63DB\u70BA\u586B\u7A7A\u514B\u6F0F\u5B57\uFF1F",
  CONVERT_HIGHLIGHTS_TO_CLOZES_DESC: '\u5728 "\u586B\u7A7A\u514B\u6F0F\u5B57\u6A21\u5F0F" \u4E2D\u52A0\u5165/\u79FB\u9664 <code>${defaultPattern}</code>',
  CONVERT_BOLD_TEXT_TO_CLOZES: "\u5C07 **\u7C97\u9AD4** \u8F49\u63DB\u70BA\u586B\u7A7A\u514B\u6F0F\u5B57\uFF1F",
  CONVERT_BOLD_TEXT_TO_CLOZES_DESC: '\u5728 "\u586B\u7A7A\u514B\u6F0F\u5B57\u6A21\u5F0F" \u4E2D\u52A0\u5165/\u79FB\u9664 <code>${defaultPattern}</code>',
  CONVERT_CURLY_BRACKETS_TO_CLOZES: "\u5C07 {{\u5927\u62EC\u865F}} \u8F49\u63DB\u70BA\u586B\u7A7A\u514B\u6F0F\u5B57\uFF1F",
  CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC: '\u5728 "\u586B\u7A7A\u514B\u6F0F\u5B57\u6A21\u5F0F" \u4E2D\u52A0\u5165/\u79FB\u9664 <code>${defaultPattern}</code>',
  CLOZE_PATTERNS: "\u586B\u7A7A\u514B\u6F0F\u5B57\u6A21\u5F0F",
  CLOZE_PATTERNS_DESC: '\u8F38\u5165\u4EE5\u63DB\u884C\u7B26\u5206\u9694\u7684\u586B\u7A7A\u514B\u6F0F\u5B57\u6A21\u5F0F. Check the <a href="${docsUrl}">wiki</a> for guidance.',
  INLINE_CARDS_SEPARATOR: "\u55AE\u884C\u5361\u7247\u7684\u5206\u9694\u5B57\u5143",
  FIX_SEPARATORS_MANUALLY_WARNING: "\u6CE8\u610F\uFF1A\u66F4\u6539\u6B64\u9078\u9805\u5F8C\u4F60\u5C07\u9700\u8981\u81EA\u884C\u66F4\u6539\u5DF2\u5B58\u5728\u5361\u7247\u7684\u5206\u9694\u5B57\u5143\u3002",
  INLINE_REVERSED_CARDS_SEPARATOR: "\u55AE\u884C\u53CD\u8F49\u5361\u7247\u7684\u5206\u9694\u5B57\u5143",
  MULTILINE_CARDS_SEPARATOR: "\u591A\u884C\u5361\u7247\u7684\u5206\u9694\u5B57\u5143",
  MULTILINE_REVERSED_CARDS_SEPARATOR: "\u591A\u884C\u7FFB\u8F49\u5361\u7247\u7684\u5206\u9694\u5B57\u5143",
  MULTILINE_CARDS_END_MARKER: "\u8868\u793A\u586B\u7A7A\u548C\u591A\u884C\u95EA\u5361\u7ED3\u675F\u7684\u5B57\u7B26",
  NOTES: "\u7B46\u8A18",
  NOTE: "Note",
  REVIEW_PANE_ON_STARTUP: "\u555F\u52D5\u6642\u958B\u555F\u7B46\u8A18\u5FA9\u7FD2\u7A97\u683C",
  TAGS_TO_REVIEW: "\u5FA9\u7FD2\u6A19\u7C64",
  TAGS_TO_REVIEW_DESC: "\u8F38\u5165\u6A19\u7C64\uFF0C\u7528\u7A7A\u683C\u6216\u63DB\u884C\u5B57\u5143\u5206\u9694\uFF0C\u4F8B\u5982\uFF1A#review #tag2 #tag3.",
  OPEN_RANDOM_NOTE: "\u5FA9\u7FD2\u96A8\u6A5F\u7B46\u8A18",
  OPEN_RANDOM_NOTE_DESC: "\u95DC\u9589\u6B64\u9078\u9805\uFF0C\u7B46\u8A18\u5C07\u4EE5\u91CD\u8981\u5EA6(PageRank)\u6392\u5E8F\u3002",
  AUTO_NEXT_NOTE: "\u5FA9\u7FD2\u5F8C\u81EA\u52D5\u6253\u958B\u4E0B\u4E00\u500B\u7B46\u8A18",
  ENABLE_FILE_MENU_REVIEW_OPTIONS: "\u8ACB\u5728\u6A94\u6848\u9078\u55AE\u4E2D\u555F\u7528\u6AA2\u8996\u9078\u9805\uFF08\u4F8B\u5982\uFF1A\u6AA2\u8996\uFF1A\u7C21\u55AE\u3001\u8A18\u5F97\u3001\u8F03\u96E3\uFF09",
  ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC: "\u5982\u679C\u60A8\u5728\u6A94\u6848\u9078\u55AE\u4E2D\u505C\u7528\u6AA2\u8996\u9078\u9805\uFF0C\u60A8\u53EF\u4EE5\u4F7F\u7528\u63D2\u4EF6\u6307\u4EE4\u6AA2\u8996\u7B46\u8A18\uFF0C\u5982\u679C\u6709\u8A2D\u5B9A\uFF0C\u4E5F\u53EF\u4EE5\u4F7F\u7528\u76F8\u95DC\u7684\u5FEB\u6377\u9375\u3002",
  MAX_N_DAYS_REVIEW_QUEUE: "\u53F3\u908A\u9762\u677F\u986F\u793A\u7684\u6700\u5927\u5929\u6578",
  MIN_ONE_DAY: "\u5929\u6578\u6700\u5C0F\u503C\u70BA1",
  VALID_NUMBER_WARNING: "\u8ACB\u8F38\u5165\u6709\u6548\u7684\u6578\u5B57\u3002",
  UI: "User Interface",
  OPEN_IN_TAB: "Open in new tab",
  OPEN_IN_TAB_DESC: "Turn this off to open the plugin in a modal window",
  SHOW_STATUS_BAR: "Show status bar",
  SHOW_STATUS_BAR_DESC: "Turn this off to hide the flashcard's review status in Obsidian's status bar",
  SHOW_RIBBON_ICON: "Show icon in the ribbon bar",
  SHOW_RIBBON_ICON_DESC: "Turn this off to hide the plugin icon from Obsidian's ribbon bar",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE: "\u724C\u7D44\u6A39\u6700\u521D\u61C9\u986F\u793A\u70BA\u5C55\u958B",
  INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC: "\u95DC\u9589\u6B64\u9078\u9805\u53EF\u647A\u758A\u540C\u4E00\u5F35\u5361\u7247\u4E2D\u7684\u5DE2\u72C0\u724C\u7D44\u3002\u5982\u679C\u60A8\u7684\u5361\u7247\u5C6C\u65BC\u540C\u4E00\u6A94\u6848\u4E2D\u7684\u8A31\u591A\u5957\u724C\uFF0C\u5247\u5F88\u6709\u7528\u3002",
  ALGORITHM: "\u6F14\u7B97\u6CD5",
  CHECK_ALGORITHM_WIKI: '\u77AD\u89E3\u66F4\u591A, \u8ACB\u9EDE\u9078<a href="${algoUrl}">\u7B97\u6CD5\u5BE6\u73FE</a>.',
  SM2_OSR_VARIANT: "OSR's variant of SM-2",
  BASE_EASE: "\u57FA\u790E\u638C\u63E1\u7A0B\u5EA6",
  BASE_EASE_DESC: "\u6700\u5C0F\u503C130\uFF0C\u63A8\u85A6\u503C\u7D04250.",
  BASE_EASE_MIN_WARNING: "\u57FA\u790E\u638C\u63E1\u7A0B\u5EA6\u7684\u6700\u5C0F\u503C\u70BA130\u3002",
  LAPSE_INTERVAL_CHANGE: "\u5C07\u5FA9\u7FD2\u6642\u6A19\u8A3B\u70BA\u300C\u8F03\u96E3\u300D\u7684\u5361\u7247\u6216\u7B46\u8A18\u5FA9\u7FD2\u9593\u9694\u7E2E\u77ED",
  LAPSE_INTERVAL_CHANGE_DESC: "\u65B0\u5FA9\u7FD2\u9593\u9694 = \u539F\u5FA9\u7FD2\u9593\u9694 * \u9593\u9694\u6539\u8B8A\u4FC2\u6578 / 100.",
  EASY_BONUS: "\u7C21\u55AE\u734E\u52F5",
  EASY_BONUS_DESC: "\u7C21\u55AE\u734E\u52F5\u8A2D\u5B9A\u300C\u8A18\u5F97\u300D\u548C\u300C\u7C21\u55AE\u300D\u5361\u7247\u6216\u7B46\u8A18\u7684\u5FA9\u7FD2\u9593\u9694\u5DEE\u8DDD\uFF08\u6700\u5C0F\u503C100%\uFF09\u3002",
  EASY_BONUS_MIN_WARNING: "\u7C21\u55AE\u734E\u52F5\u81F3\u5C11\u70BA100\u3002",
  LOAD_BALANCE: "Enable load balancer",
  LOAD_BALANCE_DESC: `Slightly tweaks the interval so that the number of reviews per day is more consistent.
        It's like Anki's fuzz but instead of being random, it picks the day with the least amount of reviews.
        It's turned off for small intervals.`,
  MAX_INTERVAL: "\u6700\u5927\u9593\u9694\uFF08\u5929\uFF09",
  MAX_INTERVAL_DESC: "\u8A2D\u5B9A\u5FA9\u7FD2\u7684\u6700\u5927\u9593\u9694\u6642\u9593\uFF08\u9810\u8A2D\u503C100\u5E74\uFF09\u3002",
  MAX_INTERVAL_MIN_WARNING: "\u6700\u5927\u9593\u9694\u81F3\u5C11\u70BA1\u5929",
  MAX_LINK_CONTRIB: "\u6700\u5927\u93C8\u63A5\u8CA2\u737B",
  MAX_LINK_CONTRIB_DESC: "\u93C8\u63A5\u7B46\u8A18\u7684\u52A0\u6B0A\u638C\u63E1\u7A0B\u5EA6\u5C0D\u539F\u59CB\u638C\u63E1\u7A0B\u5EA6\u7684\u6700\u5927\u8CA2\u737B\u3002",
  LOGGING: "\u8A18\u9304\u4E2D",
  DISPLAY_SCHEDULING_DEBUG_INFO: "\u5728\u958B\u767C\u8005\u63A7\u5236\u53F0\u4E2D\u986F\u793A\u9664\u932F\u8CC7\u8A0A",
  DISPLAY_PARSER_DEBUG_INFO: "Show the parser's debugging information on the developer console",
  SCHEDULING: "Scheduling",
  EXPERIMENTAL: "Experimental",
  HELP: "Help",
  STORE_IN_NOTES: "In the notes",
  DELETE_SCHEDULING_DATA_ALL: "Delete Scheduling Data",
  DELETE_SCHEDULING_DATA_ALL_DESC: "Delete scheduling data from all notes and flashcards.",
  DELETE: "Delete",
  CONFIRM_SCHEDULING_DATA_ALL_DELETION: "Are you sure you want to delete all scheduling data from your notes and flashcards? This action cannot be undone.",
  CONFIRM: "Confirm",
  SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS: "Scheduling data deletion in progress...",
  SCHEDULING_DATA_HAS_BEEN_DELETED: "Scheduling data has been deleted from all notes and flashcards.",
  // sidebar.ts
  NOTES_REVIEW_QUEUE: "\u7B46\u8A18\u5FA9\u7FD2\u5E8F\u5217",
  CLOSE: "\u81E8\u8FD1",
  NEW: "\u65B0",
  YESTERDAY: "\u6628\u5929",
  TODAY: "\u4ECA\u5929",
  TOMORROW: "\u660E\u5929",
  // stats-modal.tsx
  STATS_TITLE: "\u7D71\u8A08",
  MONTH: "\u6708",
  QUARTER: "\u5B63",
  YEAR: "\u5E74",
  LIFETIME: "\u5168\u90E8",
  FORECAST: "\u9810\u6E2C",
  FORECAST_DESC: "\u5C07\u8981\u5230\u671F\u7684\u5361\u7247\u6578\u91CF",
  SCHEDULED: "\u5DF2\u6392\u7A0B",
  DAYS: "\u5929",
  NUMBER_OF_CARDS: "\u5361\u7247\u6578\u91CF",
  REVIEWS_PER_DAY: "\u5E73\u5747: \u5FA9\u7FD2${avg} /\u5929",
  INTERVALS: "\u9593\u9694",
  INTERVALS_DESC: "\u5230\u4E0B\u4E00\u6B21\u5FA9\u7FD2\u7684\u6642\u9593\u9593\u9694",
  COUNT: "\u8A08\u6578",
  INTERVALS_SUMMARY: "\u5E73\u5747\u9593\u9694\u6642\u9593: ${avg}, \u6700\u9577\u9593\u9694\u6642\u9593: ${longest}",
  EASES: "\u638C\u63E1\u7A0B\u5EA6",
  EASES_SUMMARY: "\u5E73\u5747\u638C\u63E1\u7A0B\u5EA6: ${avgEase}",
  EASE: "Ease",
  CARD_TYPES: "\u5361\u7247\u578B\u5225",
  CARD_TYPES_DESC: "\u5982\u6709\uFF0C\u5C07\u986F\u793A\u96B1\u85CF\u7684\u5361\u7247",
  CARD_TYPE_NEW: "\u65B0",
  CARD_TYPE_YOUNG: "\u8F03\u65B0",
  CARD_TYPE_MATURE: "\u719F\u6089",
  CARD_TYPES_SUMMARY: "\u7E3D\u5361\u7247\u6578: ${totalCardsCount}",
  SEARCH: "Search",
  PREVIOUS: "Previous",
  NEXT: "Next",
  // settings.ts
  SETTINGS_TAB_HEADING: "Settings",
  MAIN_SETTINGS_PAGE: "MAIN_SETTINGS",
  // NoteReviewQueue.ts
  NOTE_REVIEW_QUEUE_HINT: "Click on the 3 dots next to the note to open the review menu.",
  // StatusBarManager.ts
  OPEN_DECK_FOR_REVIEW: "Open deck for review",
  UPDATE_AVAILABLE: "Update available",
  // Statistics
  PERIOD_TITLE: "Period",
  PERIOD_DESC: "Period of time to display in the charts",
  // Card controls reset button
  DELETE_SCHEDULING_DATA_OF_CURRENT_CARD: "Delete card scheduling data?",
  CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD: "Are you sure you want to delete the scheduling data from your current card? This action cannot be undone.",
  SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD: "Deleting the cards scheduling data...",
  // Settings > Scheduling
  START_OF_DAY: "Start of day",
  START_OF_DAY_DESC: "The time at which the day begins (Format: HH:MM:SS, Default: 00:00:00)",
  INVALID_START_OF_DAY_WARNING: "Invalid format for start of day",
  // Settings > main-page
  INFO: "Info",
  // Card responses
  AGAIN: "Again",
  // Settings > info
  CHECK_ROADMAP: 'Check out the <a href="${roadMapUrl}">roadmap</a> for upcoming features.',
  CHECK_DEV_NEWS: 'Check out the <a href="${devNewsUrl}">dev news</a> for the latest development news.'
};
var zh_tw_default = zhTW;

// src/lang/locale-manager.ts
var LocaleManagerInstance = class _LocaleManagerInstance {
  static getInstance() {
    if (!_LocaleManagerInstance.instance) {
      throw new Error("there is no QuestionDataStore instance.");
    }
    return _LocaleManagerInstance.instance;
  }
};
var LocaleManager = class {
  // The locale map
  constructor() {
    this.loadedLocale = import_obsidian.moment.locale();
    this.currentLocale = this.loadedLocale;
    this.localeMap = {
      af: af_default,
      ar: ar_default,
      bn: bn_default,
      cs: cz_default,
      da: da_default,
      de: de_default,
      en: en_default,
      "en-gb": en_gb_default,
      es: es_default,
      fr: fr_default,
      hi: hi_default,
      id: id_default,
      it: it_default,
      ja: ja_default,
      ko: ko_default,
      mr: mr_default,
      nl: nl_default,
      nn: no_default,
      pl: pl_default,
      pt: pt_default,
      "pt-br": pt_br_default,
      ro: ro_default,
      ru: ru_default,
      sw: sw_default,
      ta: ta_default,
      te: te_default,
      th: th_default,
      tr: tr_default,
      uk: uk_default,
      ur: ur_default,
      vi: vi_default,
      "zh-cn": zh_cn_default,
      "zh-tw": zh_tw_default
    };
  }
  /**
   * Gets the current translation.
   */
  currentTranslation() {
    const currentLocale = LocaleManagerInstance.getInstance().currentLocale;
    const currentLocaleMap = this.localeMap[currentLocale];
    if (!currentLocaleMap) {
      console.warn(`SRS error: Locale ${currentLocale} not found.`);
    }
    return currentLocaleMap;
  }
  /**
   * Gets the current locale name.
   */
  currentLocaleName() {
    return this.currentTranslation().languageName;
  }
  /**
   * Gets the current locale code.
   */
  currentLocaleCode() {
    return this.currentTranslation().language;
  }
  /**
   * Gets the list of available locales.
   */
  getLocaleOptionsList() {
    return Object.keys(this.localeMap).map((locale) => ({
      language: locale,
      languageName: this.localeMap[locale].languageName
    }));
  }
};

// src/lang/helpers.ts
LocaleManagerInstance.instance = new LocaleManager();
function insertParameters(translation, params) {
  const names2 = Object.keys(params);
  const vals = Object.values(params);
  function replaceNamesWithValues(translation2, names3, vals2) {
    let result = translation2;
    for (let i2 = 0; i2 < names3.length; i2++) {
      const name = names3[i2];
      const value = `${vals2[i2]}`;
      result = result.replace("${" + name + "}", value);
    }
    return result;
  }
  return replaceNamesWithValues(translation, names2, vals);
}
function t(translationKey, params) {
  const currentLocale = LocaleManagerInstance.getInstance().currentLocale;
  const currentLocaleMap = LocaleManagerInstance.getInstance().currentTranslation();
  const translation = currentLocale && currentLocaleMap[translationKey] || en_default[translationKey];
  if (params) {
    return insertParameters(translation, params);
  }
  return translation;
}
function tHTML(translationKey, params) {
  return parseHTMLTags(t(translationKey, params)).map(
    (translationElement) => translationElement.element
  );
}
function parseHTMLTags(translation) {
  const resultArray = [];
  for (let currentPosition = 0; currentPosition < translation.length; currentPosition++) {
    const anchorPosition = translation.indexOf("<a", currentPosition);
    const codePosition = translation.indexOf("<code", currentPosition);
    const noAnchorTagsFound = anchorPosition === -1;
    const noCodeTagsFound = codePosition === -1;
    const noTagsFound = noAnchorTagsFound && noCodeTagsFound;
    const handleAnchorFirst = anchorPosition < codePosition && !noAnchorTagsFound || noCodeTagsFound;
    const relevantPosition = handleAnchorFirst ? anchorPosition : codePosition;
    if (noTagsFound || relevantPosition > currentPosition) {
      const startOfText = resultArray.length === 0 ? 0 : resultArray[resultArray.length - 1].end + 1;
      const endOfText = noTagsFound ? translation.length - 1 : relevantPosition - 1;
      resultArray.push(createTranslationTextElement(translation, startOfText, endOfText));
      if (noTagsFound) break;
    }
    if (handleAnchorFirst) {
      const linkRegex = /<a.+href="(.+)".*>(.+)<\/a>/;
      const linkMatch = linkRegex.exec(translation);
      if (linkMatch) {
        const href = linkMatch[1];
        const text = linkMatch[2];
        const anchorElement = activeDocument.createElement("a");
        anchorElement.setAttribute("href", href);
        anchorElement.setText(text);
        resultArray.push({
          element: anchorElement,
          start: anchorPosition,
          end: anchorPosition + linkMatch[0].length - 1
        });
      } else {
        return [];
      }
      currentPosition = anchorPosition + linkMatch[0].length - 1;
    } else {
      const codeRegex = /<code.*>(.+)<\/code>/;
      const codeMatch = codeRegex.exec(translation);
      if (codeMatch) {
        const text = codeMatch[1];
        const codeElement = activeDocument.createElement("code");
        codeElement.setText(text);
        resultArray.push({
          element: codeElement,
          start: codePosition,
          end: codePosition + codeMatch[0].length - 1
        });
      } else {
        return [];
      }
      currentPosition = codePosition + codeMatch[0].length - 1;
    }
  }
  return resultArray;
}
function createTranslationTextElement(translation, start, end) {
  const text = translation.substring(start, end + 1);
  return {
    element: activeDocument.createTextNode(text),
    start,
    end
  };
}

// src/scheduling/algorithms/base/repetition-item.ts
var RepetitionItem = class {
  constructor(repetitionItemType, repetitionPhase, scheduleInfo, storageInfo) {
    this.repItemType = repetitionItemType;
    this.repetitionPhase = repetitionPhase;
    this.scheduleInfo = scheduleInfo;
    this.storageInfo = storageInfo;
  }
  // scheduling
  get hasSchedule() {
    return this.scheduleInfo !== null;
  }
  get isNew() {
    return !this.hasSchedule;
  }
  get isDue() {
    return this.scheduleInfo !== null && this.scheduleInfo.isDue();
  }
  get repItemState() {
    return this.isNew ? 0 /* NewItem */ : 1 /* DueItem */;
  }
};

// src/data/constants.ts
var SR_COMMENT_AND_WHITESPACE_FINDER = /\s?<!--SR:!.+?-->/g;
var SM2_SCHEDULE_INFO_EXTRACTOR = /<!--SR:!(.+?),(\d+),(\d+),*(\d+)*-->/gm;
var MULTI_SCHEDULING_EXTRACTOR = /!([\d-]+),(\d+),(\d+)/gm;
var OBSIDIAN_TAG_AT_STARTOFLINE_REGEX = /^#[^\s#]+/gi;
var OBSIDIAN_BLOCK_ID_ENDOFLINE_REGEX = / (\^[a-zA-Z0-9-]+)$/;
var SR_METADATA_CALLOUT = "> [!sr|card-metadata]";
var PREFERRED_DATE_FORMAT = "YYYY-MM-DD";
var ALLOWED_DATE_FORMATS = [PREFERRED_DATE_FORMAT, "DD-MM-YYYY", "ddd MMM DD YYYY"];
var TICKS_PER_DAY = 24 * 3600 * 1e3;
var SR_HTML_COMMENT_BEGIN = "<!--SR:";
var SR_HTML_COMMENT_END = "-->";
var SR_TAB_VIEW = "spaced-repetition-tab-view";
var DEBUG_MODE_ENABLED = false;

// src/data/data-store/base/data-store.ts
var DataStore = class _DataStore {
  static getInstance() {
    if (!_DataStore.instance) {
      throw new Error("there is no QuestionDataStore instance.");
    }
    return _DataStore.instance;
  }
};

// src/data/data-structures/deck/topic-path.ts
var TopicPath = class _TopicPath {
  constructor(path2) {
    if (path2 === null) throw new Error("path is null");
    if (path2.some((str) => str.includes("/")))
      throw new Error("path entries must not contain '/'");
    this.path = path2;
  }
  get hasPath() {
    return this.path.length > 0;
  }
  get isEmptyPath() {
    return !this.hasPath;
  }
  static get emptyPath() {
    return new _TopicPath([]);
  }
  shift() {
    if (this.isEmptyPath) throw new Error("can't shift an empty path");
    return this.path.shift();
  }
  clone() {
    return new _TopicPath([...this.path]);
  }
  formatAsTag() {
    if (this.isEmptyPath) throw new Error("Empty path");
    const result = "#" + this.path.join("/");
    return result;
  }
  static getTopicPathOfFile(noteFile, settings) {
    let result = _TopicPath.emptyPath;
    if (settings.convertFoldersToDecks) {
      const deckPath = noteFile.path.split("/");
      deckPath.pop();
      if (deckPath.length !== 0) {
        result = new _TopicPath(deckPath);
      }
    } else {
      const tagList = this.getTopicPathsFromTagList(
        noteFile.getAllTagsFromCache()
      );
      outer: for (const tagToReview of this.getTopicPathsFromTagList(
        settings.flashcardTags
      )) {
        for (const tag of tagList) {
          if (tagToReview.isSameOrAncestorOf(tag)) {
            result = tag;
            break outer;
          }
        }
      }
    }
    return result;
  }
  isSameOrAncestorOf(topicPath) {
    if (this.isEmptyPath) return topicPath.isEmptyPath;
    if (this.path.length > topicPath.path.length) return false;
    for (let i2 = 0; i2 < this.path.length; i2++) {
      if (this.path[i2] !== topicPath.path[i2]) return false;
    }
    return true;
  }
  static getTopicPathFromCardText(cardText) {
    var _a2;
    const path2 = (_a2 = cardText.trimStart().match(OBSIDIAN_TAG_AT_STARTOFLINE_REGEX)) == null ? void 0 : _a2.slice(-1)[0];
    return (path2 == null ? void 0 : path2.length) > 0 ? _TopicPath.getTopicPathFromTag(path2) : null;
  }
  static getTopicPathsFromTagList(tagList) {
    const result = [];
    for (const tag of tagList) {
      if (this.isValidTag(tag)) result.push(_TopicPath.getTopicPathFromTag(tag));
    }
    return result;
  }
  static isValidTag(tag) {
    if (tag === null || tag.length === 0) return false;
    if (tag[0] !== "#") return false;
    if (tag.length === 1) return false;
    return true;
  }
  static getTopicPathFromTag(tag) {
    if (tag === null || tag.length === 0) throw new Error("Null/empty tag");
    if (tag[0] !== "#") throw new Error("Tag must start with #");
    if (tag.length === 1) throw new Error("Invalid tag");
    const path2 = tag.replace("#", "").split("/").filter((str) => str);
    return new _TopicPath(path2);
  }
  static getFolderPathFromFilename(noteFile, settings) {
    let result = _TopicPath.emptyPath;
    if (settings.convertFoldersToDecks) {
      const deckPath = noteFile.path.split("/");
      deckPath.pop();
      if (deckPath.length !== 0) {
        result = new _TopicPath(deckPath);
      }
    }
    return result;
  }
};
var TopicPathList = class _TopicPathList {
  constructor(list, lineNum = null) {
    if (list === null) throw new Error("TopicPathList null");
    this.list = list;
    this.lineNum = lineNum;
  }
  get length() {
    return this.list.length;
  }
  isAnyElementSameOrAncestorOf(topicPath) {
    return this.list.some((item) => item.isSameOrAncestorOf(topicPath));
  }
  formatPsv() {
    return this.format("|");
  }
  format(sep2) {
    return this.list.map((topicPath) => topicPath.formatAsTag()).join(sep2);
  }
  static empty() {
    return new _TopicPathList([]);
  }
  static fromPsv(str, lineNum) {
    const result = _TopicPathList.convertTagListToTopicPathList(str.split("|"));
    result.lineNum = lineNum;
    return result;
  }
  //
  // tagList is a list of tags such as:
  //      ["#flashcards/computing", "#boring-stuff", "#news-worthy"]
  // validTopicPathList is a list of valid tags, such as those from settings.flashcardTags,E.g.
  //      ["#flashcards"]
  //
  // This returns a filtered version of tagList, containing only topic paths that are considered valid.
  // Validity is defined as "isAnyElementSameOrAncestorOf", and "#flashcards" is considered the ancestor of
  // "#flashcards/computing".
  //
  // Therefore this would return:
  //      "#flashcards/computing" (but not "#boring-stuff" or "#news-worthy")
  //
  static filterValidTopicPathsFromTagList(list, validTopicPathList, lineNum = null) {
    const result = [];
    for (const tag of list.list) {
      if (validTopicPathList.isAnyElementSameOrAncestorOf(tag)) result.push(tag);
    }
    return new _TopicPathList(result, lineNum);
  }
  static convertTagListToTopicPathList(tagList) {
    const result = [];
    for (const tag of tagList) {
      if (TopicPath.isValidTag(tag)) result.push(TopicPath.getTopicPathFromTag(tag));
    }
    return new _TopicPathList(result);
  }
};
var TopicPathWithWs = class {
  constructor(topicPath, preWhitespace, postWhitespace) {
    if (!topicPath || topicPath.isEmptyPath) throw new Error("topicPath null");
    this.topicPath = topicPath;
    this.preWhitespace = preWhitespace;
    this.postWhitespace = postWhitespace;
  }
  formatWithWs() {
    return `${this.preWhitespace}${this.topicPath.formatAsTag()}${this.postWhitespace}`;
  }
};

// src/utils/dates.ts
var import_moment = __toESM(require_moment());
function formatDate(arg1, arg2, arg3, format = PREFERRED_DATE_FORMAT) {
  let _date = null;
  if (typeof arg1 === "number" && typeof arg2 === "number" && typeof arg3 === "number") {
    _date = new Date(arg1, arg2 - 1, arg3);
  } else if (typeof arg1 === "number") {
    _date = new Date(arg1);
  } else if (typeof arg1 === typeof /* @__PURE__ */ new Date()) {
    _date = arg1;
  }
  if (!_date) return "";
  let result = format;
  result = result.replaceAll(/YYYY/g, _date.getFullYear().toString().padStart(4, "0"));
  result = result.replaceAll(/MM/g, (_date.getMonth() + 1).toString().padStart(2, "0"));
  result = result.replaceAll(/DD/g, _date.getDate().toString().padStart(2, "0"));
  return result;
}
function formatDateWithMoment(ticks, format) {
  return (0, import_moment.default)(ticks).format(format);
}
var LiveDateProvider = class {
  constructor() {
    this.dayBoundary = null;
  }
  get now() {
    return (0, import_moment.default)();
  }
  get today() {
    let result = (0, import_moment.default)().startOf("day");
    if (this.dayBoundary && this.dayBoundary.hour !== 0 && this.dayBoundary.minute !== 0 && this.dayBoundary.second !== 0) {
      const nowTime = (0, import_moment.default)();
      const customDayBoundary = (0, import_moment.default)().hour(this.dayBoundary.hour).minute(this.dayBoundary.minute).second(this.dayBoundary.second).millisecond(0);
      if (nowTime.isBefore(customDayBoundary)) {
        result = (0, import_moment.default)().startOf("day").subtract(1, "day");
      } else {
        result = (0, import_moment.default)().startOf("day");
      }
    }
    return result;
  }
  getDayBoundary() {
    return this.dayBoundary;
  }
  setDayBoundary(dayBoundary) {
    this.dayBoundary = dayBoundary;
  }
};
var DateUtil = class {
  static dateStrToMoment(str) {
    return (0, import_moment.default)(str, ALLOWED_DATE_FORMATS);
  }
  static strToDayBoundary(str) {
    const dayStr = str.split(":");
    if (dayStr.length !== 3) {
      return null;
    }
    const hour = parseInt(dayStr[0]);
    if (hour < 0 || hour > 23 || Number.isNaN(hour)) {
      return null;
    }
    const minute = parseInt(dayStr[1]);
    if (minute < 0 || minute > 59 || Number.isNaN(minute)) {
      return null;
    }
    const second = parseInt(dayStr[2]);
    if (second < 0 || second > 59 || Number.isNaN(second)) {
      return null;
    }
    const dayBoundary = {
      hour,
      minute,
      second
    };
    return dayBoundary;
  }
};
var globalDateProvider = new LiveDateProvider();

// src/scheduling/flashcard-review-sequencer.ts
var DeckStats = class {
  constructor(totalCount, dueCount, newCount, cardsInQueueCount, dueCardsInQueueOfThisDeckCount, newCardsInQueueOfThisDeckCount, cardsInQueueOfThisDeckCount, subDecksInQueueOfThisDeckCount, decksInQueueOfThisDeckCount) {
    this.dueCount = dueCount;
    this.newCount = newCount;
    this.totalCount = totalCount;
    this.cardsInQueueCount = cardsInQueueCount;
    this.dueCardsInQueueOfThisDeckCount = dueCardsInQueueOfThisDeckCount;
    this.newCardsInQueueOfThisDeckCount = newCardsInQueueOfThisDeckCount;
    this.cardsInQueueOfThisDeckCount = cardsInQueueOfThisDeckCount;
    this.subDecksInQueueOfThisDeckCount = subDecksInQueueOfThisDeckCount;
    this.decksInQueueOfThisDeckCount = decksInQueueOfThisDeckCount;
  }
};
var FlashcardReviewSequencer = class {
  constructor(reviewMode, cardSequencer, settings, srsAlgorithm, questionPostponementList, dueDateFlashcardHistogram) {
    this.pendingCards = [];
    this.currentTopicPath = TopicPath.emptyPath;
    this.reviewMode = reviewMode;
    this.cardSequencer = cardSequencer;
    this.settings = settings;
    this.srsAlgorithm = srsAlgorithm;
    this.questionPostponementList = questionPostponementList;
    this.dueDateFlashcardHistogram = dueDateFlashcardHistogram;
  }
  get hasCurrentCard() {
    return this.cardSequencer.currentRepItem !== null && this.cardSequencer.currentRepItem !== void 0;
  }
  get hasPendingCards() {
    return this.pendingCards.length > 0;
  }
  get currentCard() {
    return this.cardSequencer.currentRepItem;
  }
  get currentQuestion() {
    var _a2;
    return (_a2 = this.currentCard) == null ? void 0 : _a2.question;
  }
  get currentDeck() {
    return this.cardSequencer.currentDeck;
  }
  get nextPendingDueUnix() {
    return this.pendingCards.length > 0 ? Math.min(...this.pendingCards.map((pendingCard) => pendingCard.dueUnix)) : null;
  }
  get currentNote() {
    return this.currentQuestion.note;
  }
  // originalDeckTree isn't modified by the review process
  // Only remainingDeckTree
  setDeckTree(originalDeckTree, remainingDeckTree) {
    this.cardSequencer.setBaseDeck(remainingDeckTree);
    this._originalDeckTree = originalDeckTree;
    this.remainingDeckTree = remainingDeckTree;
    this.pendingCards = [];
    this.setCurrentDeck(TopicPath.emptyPath);
  }
  setCurrentDeck(topicPath) {
    this.currentTopicPath = topicPath;
    this.wakeDuePendingCards();
    this.cardSequencer.setIteratorTopicPath(topicPath);
    this.cardSequencer.nextRepItem();
  }
  refreshCurrentDeck() {
    this.setCurrentDeck(this.currentTopicPath);
  }
  get originalDeckTree() {
    return this._originalDeckTree;
  }
  getDeckStats(topicPath) {
    this.wakeDuePendingCards();
    const totalCount = this._originalDeckTree.getDeck(topicPath).getDistinctRepItemCount(2 /* AnyItem */, true);
    const remainingDeck = this.remainingDeckTree.getDeck(topicPath);
    const newCount = remainingDeck.getDistinctRepItemCount(0 /* NewItem */, true);
    const dueCount = remainingDeck.getDistinctRepItemCount(1 /* DueItem */, true);
    const newCardsInQueueOfThisDeckCount = remainingDeck.getDistinctRepItemCount(
      0 /* NewItem */,
      false
    );
    const dueCardsInQueueOfThisDeckCount = remainingDeck.getDistinctRepItemCount(
      1 /* DueItem */,
      false
    );
    const cardsInQueueOfThisDeckCount = newCardsInQueueOfThisDeckCount + dueCardsInQueueOfThisDeckCount;
    const subDecksInQueueOfThisDeckCount = this.getSubDecksWithCardsInQueue(remainingDeck).length;
    const decksInQueueOfThisDeckCount = cardsInQueueOfThisDeckCount > 0 ? subDecksInQueueOfThisDeckCount + 1 : subDecksInQueueOfThisDeckCount;
    return new DeckStats(
      totalCount,
      dueCount,
      newCount,
      dueCount + newCount,
      dueCardsInQueueOfThisDeckCount,
      newCardsInQueueOfThisDeckCount,
      cardsInQueueOfThisDeckCount,
      subDecksInQueueOfThisDeckCount,
      decksInQueueOfThisDeckCount
    );
  }
  getSubDecksWithCardsInQueue(deck) {
    this.wakeDuePendingCards();
    let subDecksWithCardsInQueue = [];
    deck.subdecks.forEach((subDeck) => {
      subDecksWithCardsInQueue = subDecksWithCardsInQueue.concat(
        this.getSubDecksWithCardsInQueue(subDeck)
      );
      const newCount = subDeck.getDistinctRepItemCount(0 /* NewItem */, false);
      const dueCount = subDeck.getDistinctRepItemCount(1 /* DueItem */, false);
      if (newCount + dueCount > 0) subDecksWithCardsInQueue.push(subDeck);
    });
    return subDecksWithCardsInQueue;
  }
  skipCurrentCard() {
    this.cardSequencer.deleteCurrentQuestionFromAllDecks();
  }
  deleteCurrentCard() {
    this.cardSequencer.deleteCurrentRepItemFromAllDecks();
  }
  async processReview(response) {
    switch (this.reviewMode) {
      case 1 /* Review */:
        await this.processReviewReviewMode(response);
        break;
      case 0 /* Cram */:
        this.processReviewCramMode(response);
        break;
    }
  }
  async processReviewReviewMode(response) {
    let shortTermRequeue = "none";
    if (response !== 4 /* Reset */ || this.currentCard.hasSchedule) {
      const oldSchedule = this.currentCard.scheduleInfo;
      this.currentCard.scheduleInfo = this.determineCardSchedule(response, this.currentCard);
      shortTermRequeue = this.getShortTermRequeueMode(this.currentCard.scheduleInfo);
      await DataStore.getInstance().writeSchedule(this.currentQuestion);
      if (oldSchedule) {
        const now2 = globalDateProvider.now.valueOf();
        const nDays = Math.ceil((oldSchedule.dueDateAsUnix - now2) / TICKS_PER_DAY);
        this.dueDateFlashcardHistogram.decrement(nDays);
      }
      this.dueDateFlashcardHistogram.increment(this.currentCard.scheduleInfo.interval);
    } else if (response === 4 /* Reset */) {
      shortTermRequeue = "immediate";
    }
    if (shortTermRequeue === "pending") {
      await this.handlePendingRequeue();
    } else if (shortTermRequeue === "immediate" || response === 4 /* Reset */) {
      if (this.settings.burySiblingCards) {
        await this.burySiblingCards();
        this.deleteSiblingCardsFromAllDecks();
      }
      this.cardSequencer.moveCurrentRepItemToEndOfList();
      this.cardSequencer.nextRepItem();
    } else {
      if (this.settings.burySiblingCards) {
        await this.burySiblingCards();
        this.cardSequencer.deleteCurrentQuestionFromAllDecks();
      } else {
        this.deleteCurrentCard();
      }
    }
  }
  async burySiblingCards() {
    const remaining = this.currentDeck.getQuestionRepItemCount(this.currentQuestion);
    if (remaining > 1) {
      this.questionPostponementList.add(this.currentQuestion);
      await this.questionPostponementList.write();
    }
  }
  deleteSiblingCardsFromAllDecks() {
    for (const siblingCard of this.currentQuestion.cards) {
      if (Object.is(siblingCard, this.currentCard)) {
        continue;
      }
      this.remainingDeckTree.deleteCardFromAllDecks(siblingCard, false);
    }
  }
  async handlePendingRequeue() {
    var _a2;
    const pendingCard = this.currentCard;
    const dueUnix = (_a2 = pendingCard.scheduleInfo) == null ? void 0 : _a2.dueDateAsUnix;
    if (this.settings.burySiblingCards) {
      await this.burySiblingCards();
      this.deleteSiblingCardsFromAllDecks();
    }
    this.cardSequencer.deleteCurrentRepItemFromAllDecks();
    this.pendingCards.push({ card: pendingCard, dueUnix });
  }
  processReviewCramMode(response) {
    if (response === 0 /* Easy */) this.deleteCurrentCard();
    else {
      this.cardSequencer.moveCurrentRepItemToEndOfList();
      this.cardSequencer.nextRepItem();
    }
  }
  getShortTermRequeueMode(scheduleInfo) {
    if (!scheduleInfo || scheduleInfo.interval >= 1) {
      return "none";
    }
    return scheduleInfo.isDue() ? "immediate" : "pending";
  }
  wakeDuePendingCards() {
    if (this.pendingCards.length === 0) {
      return;
    }
    const nowUnix = globalDateProvider.now.valueOf();
    const remainingPendingCards = [];
    for (const pendingCard of this.pendingCards) {
      if (pendingCard.dueUnix <= nowUnix) {
        this.remainingDeckTree.appendRepItem(
          pendingCard.card.question.topicPathList,
          pendingCard.card
        );
      } else {
        remainingPendingCards.push(pendingCard);
      }
    }
    this.pendingCards = remainingPendingCards;
  }
  determineCardSchedule(response, card) {
    let result;
    if (response === 4 /* Reset */) {
      result = this.srsAlgorithm.cardGetResetSchedule();
    } else {
      if (card.hasSchedule) {
        result = this.srsAlgorithm.cardCalcUpdatedSchedule(
          response,
          card.scheduleInfo,
          this.dueDateFlashcardHistogram
        );
      } else {
        const currentNote = card.question.note;
        result = this.srsAlgorithm.cardGetNewSchedule(
          response,
          currentNote.filePath,
          this.dueDateFlashcardHistogram
        );
      }
    }
    return result;
  }
  async updateCurrentQuestionText(text) {
    const q2 = this.currentQuestion.questionText;
    q2.actualQuestion = text;
    await DataStore.getInstance().write(this.currentQuestion);
  }
  async deleteCurrentCardFromNote() {
    const question = this.currentQuestion;
    await DataStore.getInstance().delete(question);
    this._originalDeckTree.deleteQuestionFromAllDecks(question, false);
    this.cardSequencer.deleteCurrentQuestionFromAllDecks();
  }
};

// src/ui/ui-manager.tsx
var import_obsidian32 = require("obsidian");

// src/icons/app-icon.ts
var import_obsidian2 = require("obsidian");
function appIcon() {
  (0, import_obsidian2.addIcon)(
    "SpacedRepIcon",
    `<path fill="currentColor" stroke="currentColor" d="M 88.960938 17.257812 L 47.457031 17.257812 C 45.679688 17.257812 44.230469 18.703125 44.230469 20.484375 L 44.230469 86.558594 C 44.230469 88.335938 45.679688 89.785156 47.457031 89.785156 L 88.960938 89.785156 C 90.738281 89.785156 92.1875 88.335938 92.1875 86.558594 L 92.1875 20.484375 C 92.1875 18.703125 90.738281 17.257812 88.960938 17.257812 Z M 88.28125 85.878906 L 48.136719 85.878906 L 48.136719 21.164062 L 88.28125 21.164062 Z M 88.28125 85.878906 "/>
        <path fill="currentColor" stroke="currentColor"  d="M 88.960938 9.445312 L 61.667969 9.445312 C 59.925781 3.816406 54.011719 0.515625 48.269531 2.054688 L 8.183594 12.796875 C 2.304688 14.371094 -1.199219 20.4375 0.378906 26.316406 L 17.476562 90.140625 C 18.796875 95.066406 23.269531 98.324219 28.144531 98.324219 C 29.085938 98.324219 30.046875 98.199219 31 97.945312 L 40.765625 95.328125 C 42.625 96.75 44.941406 97.597656 47.457031 97.597656 L 88.960938 97.597656 C 95.046875 97.597656 100 92.644531 100 86.558594 L 100 20.484375 C 100 14.398438 95.046875 9.445312 88.960938 9.445312 Z M 29.988281 94.171875 C 26.1875 95.191406 22.269531 92.925781 21.25 89.128906 L 4.152344 25.304688 C 3.132812 21.507812 5.394531 17.585938 9.195312 16.570312 L 49.28125 5.828125 C 52.578125 4.945312 55.960938 6.53125 57.464844 9.445312 L 47.457031 9.445312 C 41.371094 9.445312 36.417969 14.398438 36.417969 20.484375 L 36.417969 86.558594 C 36.417969 88.558594 36.957031 90.433594 37.890625 92.054688 Z M 96.09375 86.558594 C 96.09375 90.492188 92.894531 93.691406 88.960938 93.691406 L 47.457031 93.691406 C 43.523438 93.691406 40.324219 90.492188 40.324219 86.558594 L 40.324219 20.484375 C 40.324219 16.550781 43.523438 13.351562 47.457031 13.351562 L 88.960938 13.351562 C 92.894531 13.351562 96.09375 16.550781 96.09375 20.484375 Z M 96.09375 86.558594 "/>
        <path fill="currentColor" stroke="currentColor"  d="M 54.101562 53.09375 L 60.070312 57.410156 L 57.789062 64.378906 C 56.90625 67.074219 59.996094 69.320312 62.285156 67.648438 L 68.210938 63.324219 L 74.132812 67.648438 C 76.421875 69.320312 79.511719 67.074219 78.628906 64.378906 L 76.347656 57.410156 L 82.320312 53.09375 C 84.613281 51.433594 83.441406 47.804688 80.605469 47.804688 L 73.242188 47.804688 L 70.988281 40.839844 C 70.117188 38.144531 66.300781 38.144531 65.429688 40.839844 L 63.179688 47.804688 L 55.8125 47.804688 C 52.980469 47.804688 51.804688 51.433594 54.101562 53.09375 Z M 54.101562 53.09375 "/>
        `
  );
}

// src/ui/obsidian-ui-components/item-views/sr-tab-view.tsx
var import_obsidian17 = require("obsidian");

// src/ui/obsidian-ui-components/content-container/content-manager.tsx
var import_moment4 = __toESM(require_moment());
var import_obsidian16 = require("obsidian");

// src/ui/obsidian-ui-components/content-container/card-container/card-container.tsx
var import_moment3 = __toESM(require_moment());
var import_obsidian11 = require("obsidian");

// src/data/data-store/base/data-store-algorithm.ts
var DataStoreAlgorithm = class _DataStoreAlgorithm {
  static getInstance() {
    if (!_DataStoreAlgorithm.instance) {
      throw new Error("there is no DataStoreAlgorithm instance.");
    }
    return _DataStoreAlgorithm.instance;
  }
};

// src/utils/strings.ts
function literalStringReplace(text, searchStr, replacementStr) {
  let result = text;
  const startIdx = text.indexOf(searchStr);
  if (startIdx >= 0) {
    const startStr = text.substring(0, startIdx);
    const endIdx = startIdx + searchStr.length;
    const endStr = text.substring(endIdx);
    result = startStr + replacementStr + endStr;
  }
  return result;
}
function cyrb53(str, seed = 0) {
  let h12 = 3735928559 ^ seed, h22 = 1103547991 ^ seed;
  for (let i2 = 0, ch; i2 < str.length; i2++) {
    ch = str.charCodeAt(i2);
    h12 = Math.imul(h12 ^ ch, 2654435761);
    h22 = Math.imul(h22 ^ ch, 1597334677);
  }
  h12 = Math.imul(h12 ^ h12 >>> 16, 2246822507) ^ Math.imul(h22 ^ h22 >>> 13, 3266489909);
  h22 = Math.imul(h22 ^ h22 >>> 16, 2246822507) ^ Math.imul(h12 ^ h12 >>> 13, 3266489909);
  return (4294967296 * (2097151 & h22) + (h12 >>> 0)).toString(16);
}
function splitTextIntoLineArray(text) {
  return text.replaceAll(/\r\n|\r/g, "\n").split("\n");
}
function stringTrimStart(str) {
  if (!str) {
    return ["", ""];
  }
  const trimmed = str.trimStart();
  const wsCount = str.length - trimmed.length;
  const ws = str.substring(0, wsCount);
  return [ws, trimmed];
}
function splitNoteIntoFrontmatterAndContent(str) {
  const lines = splitTextIntoLineArray(str);
  let lineIndex = 0;
  let hasFrontmatter = false;
  do {
    if (lineIndex === 0 && lines[lineIndex] === "---") {
      hasFrontmatter = true;
    } else if (hasFrontmatter && lines[lineIndex] === "---") {
      hasFrontmatter = false;
      lineIndex++;
    }
    if (hasFrontmatter) {
      lineIndex++;
    }
  } while (hasFrontmatter && lineIndex < lines.length);
  if (hasFrontmatter) {
    lineIndex = 0;
  }
  const frontmatter = lines.slice(0, lineIndex).join("\n");
  const emptyLines = lineIndex > 0 ? Array(lineIndex).join(".").split(".") : [];
  const content = emptyLines.concat(lines.slice(lineIndex)).join("\n");
  return [frontmatter, content];
}
function findLineIndexOfSearchStringIgnoringWs(lines, searchString) {
  let result = -1;
  for (let i2 = 0; i2 < lines.length; i2++) {
    if (lines[i2].trim() === searchString) {
      result = i2;
      break;
    }
  }
  return result;
}
function parseObsidianFrontmatterTag(tagStr) {
  const result = [];
  if (tagStr !== null) {
    const tagStrList = (tagStr + "").split(",");
    for (const tag of tagStrList) {
      if (tag !== "") {
        result.push(tag.startsWith("#") ? tag : "#" + tag);
      }
    }
  }
  return result;
}
var MultiLineTextFinder = class _MultiLineTextFinder {
  static findAndReplace(sourceText, searchText, replacementText) {
    let result = null;
    if (sourceText.includes(searchText)) {
      result = literalStringReplace(sourceText, searchText, replacementText);
    } else {
      const sourceTextArray = splitTextIntoLineArray(sourceText);
      const searchTextArray = splitTextIntoLineArray(searchText);
      const lineNo = _MultiLineTextFinder.find(
        sourceTextArray,
        searchTextArray
      );
      if (lineNo !== null && lineNo !== void 0) {
        const replacementTextArray = splitTextIntoLineArray(replacementText);
        const linesToRemove = searchTextArray.length;
        sourceTextArray.splice(lineNo, linesToRemove, ...replacementTextArray);
        result = sourceTextArray.join("\n");
      }
    }
    return result;
  }
  static find(sourceText, searchText) {
    let result = null;
    let searchIdx = 0;
    const maxSearchIdx = searchText.length - 1;
    for (let sourceIdx = 0; sourceIdx < sourceText.length; sourceIdx++) {
      const sourceLine = sourceText[sourceIdx].trim();
      const searchLine = searchText[searchIdx].trim();
      if (searchLine === sourceLine) {
        if (searchIdx === maxSearchIdx) {
          result = sourceIdx - searchIdx;
          break;
        }
        searchIdx++;
      } else {
        searchIdx = 0;
      }
    }
    return result;
  }
};

// src/data/data-structures/card/questions/question.ts
var QuestionText = class _QuestionText {
  constructor(original, topicPathWithWs, actualQuestion, textDirection, blockId) {
    this.original = original;
    this.topicPathWithWs = topicPathWithWs;
    this.actualQuestion = actualQuestion;
    this.textDirection = textDirection;
    this.obsidianBlockId = blockId;
    this.textHash = cyrb53(this.formatTopicAndQuestion());
  }
  endsWithCodeBlock() {
    return this.actualQuestion.endsWith("```");
  }
  static create(original, textDirection, settings) {
    const [topicPathWithWs, actualQuestion, blockId] = this.splitText(original, settings);
    return new _QuestionText(original, topicPathWithWs, actualQuestion, textDirection, blockId);
  }
  static splitText(original, settings) {
    const originalWithoutSR = DataStore.getInstance().removeScheduleInfo(original);
    let actualQuestion = originalWithoutSR.trimEnd();
    let topicPathWithWs = null;
    const topicPath = TopicPath.getTopicPathFromCardText(originalWithoutSR);
    if (topicPath == null ? void 0 : topicPath.hasPath) {
      const [preTopicPathWs, cardText2] = stringTrimStart(originalWithoutSR);
      const cardText3 = cardText2.replaceAll(OBSIDIAN_TAG_AT_STARTOFLINE_REGEX, "");
      let postTopicPathWs;
      [postTopicPathWs, actualQuestion] = stringTrimStart(cardText3);
      if (!settings.convertFoldersToDecks) {
        topicPathWithWs = new TopicPathWithWs(topicPath, preTopicPathWs, postTopicPathWs);
      }
    }
    const [strippedQuestion, blockId] = this.extractObsidianBlockId(actualQuestion);
    return [topicPathWithWs, strippedQuestion, blockId];
  }
  static extractObsidianBlockId(text) {
    let question = text;
    let blockId = null;
    const match2 = text.match(OBSIDIAN_BLOCK_ID_ENDOFLINE_REGEX);
    if (match2) {
      blockId = match2[0].trim();
      const newLength = question.length - blockId.length;
      question = question.substring(0, newLength).trimEnd();
    }
    return [question, blockId];
  }
  formatTopicAndQuestion() {
    let result = "";
    if (this.topicPathWithWs) {
      result += this.topicPathWithWs.formatWithWs();
    }
    result += this.actualQuestion;
    return result;
  }
};
var Question = class _Question {
  get questionType() {
    return this.parsedQuestionInfo.cardType;
  }
  get lineNo() {
    return this.parsedQuestionInfo.firstLineNum;
  }
  constructor(init) {
    Object.assign(this, init);
  }
  getHtmlCommentSeparator(settings, hasMetadataCallout) {
    const sep2 = this.isCardCommentsOnSameLine(settings) || hasMetadataCallout ? " " : "\n";
    return sep2;
  }
  isCardCommentsOnSameLine(settings) {
    let result = settings.cardCommentOnSameLine;
    if (this.questionText.endsWithCodeBlock()) {
      result = false;
    }
    return result;
  }
  setCardList(cards) {
    this.cards = cards;
    this.cards.forEach((card) => card.question = this);
  }
  formatForNote(settings) {
    let result = this.questionText.formatTopicAndQuestion();
    const blockId = this.questionText.obsidianBlockId;
    const hasSchedule = this.cards.some((card) => card.hasSchedule);
    if (hasSchedule) {
      result = result.trimEnd();
      const scheduleHtml = DataStoreAlgorithm.getInstance().questionFormatScheduleAsHtmlComment(this);
      if (scheduleHtml) {
        const isScheduleInSRMetadataCallout = result.includes(SR_METADATA_CALLOUT);
        if (settings.useCalloutsForSchedulingComments && !isScheduleInSRMetadataCallout) {
          result += `${result.endsWith("\n") ? "" : "\n"}${SR_METADATA_CALLOUT} 
> `;
        }
        if (blockId) {
          if (this.isCardCommentsOnSameLine(settings) || isScheduleInSRMetadataCallout || settings.useCalloutsForSchedulingComments)
            result += ` ${scheduleHtml} ${blockId}`;
          else result += ` ${blockId}
${scheduleHtml}`;
        } else {
          result += this.getHtmlCommentSeparator(
            settings,
            isScheduleInSRMetadataCallout || settings.useCalloutsForSchedulingComments
          ) + scheduleHtml;
        }
      } else {
        if (blockId) {
          result += ` ${blockId}`;
        }
      }
    } else {
      if (blockId) result += ` ${blockId}`;
    }
    return result;
  }
  updateQuestionWithinNoteText(noteText, settings) {
    const originalText = this.questionText.original;
    const replacementText = this.formatForNote(settings);
    let newText = MultiLineTextFinder.findAndReplace(noteText, originalText, replacementText);
    if (newText) {
      this.questionText = QuestionText.create(
        replacementText,
        this.questionText.textDirection,
        settings
      );
    } else {
      console.warn(
        `updateQuestionText: Text not found: ${originalText.substring(
          0,
          100
        )} in note: ${noteText.substring(0, 100)}`
      );
      newText = noteText;
    }
    return newText;
  }
  async writeQuestion(settings) {
    const fileText = await this.note.file.read();
    const newText = this.updateQuestionWithinNoteText(fileText, settings);
    await this.note.file.write(newText);
    this.hasChanged = false;
  }
  formatTopicPathList() {
    return this.topicPathList.format("|");
  }
  static Create(settings, parsedQuestionInfo, noteTopicPathList, textDirection, context) {
    const questionText = QuestionText.create(
      parsedQuestionInfo.text,
      textDirection,
      settings
    );
    let topicPathList = noteTopicPathList;
    if (questionText.topicPathWithWs) {
      topicPathList = new TopicPathList([questionText.topicPathWithWs.topicPath]);
    }
    const result = new _Question({
      parsedQuestionInfo,
      topicPathList,
      questionText,
      questionContext: context,
      cards: void 0,
      hasChanged: false
    });
    return result;
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/context-section/context-section.tsx
var ContextSectionComponent = class {
  constructor(parentEl) {
    this.contextSection = parentEl.createDiv();
    this.contextSection.addClass("sr-context");
  }
  updateCardContext(showContextInCards, currentQuestion, currentNote) {
    if (!showContextInCards) {
      this.contextSection.setText("");
      this.contextSection.addClass("sr-is-hidden");
      return;
    }
    if (this.contextSection.hasClass("sr-is-hidden")) {
      this.contextSection.removeClass("sr-is-hidden");
    }
    this.contextSection.setText(
      ` ${this._formatQuestionContextText(currentQuestion.questionContext, currentNote)}`
    );
  }
  _formatQuestionContextText(questionContext, currentNote) {
    const separator = " > ";
    let result = currentNote.file.basename;
    questionContext.forEach((context) => {
      if (context.startsWith("[[") && context.endsWith("]]")) {
        context = context.replace("[[", "").replace("]]", "");
        if (context.contains("|")) {
          context = context.split("|")[1];
        }
      }
      result += separator + context;
    });
    return result;
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/response-section/response-section.tsx
var import_obsidian4 = require("obsidian");

// src/scheduling/algorithms/schedule-display.ts
var import_moment2 = __toESM(require_moment());

// src/scheduling/algorithms/osr/note-scheduling.ts
function osrSchedule(response, originalInterval, ease, delayedBeforeReview, settings, dueDateHistogram) {
  const delayedBeforeReviewDays = Math.max(0, Math.floor(delayedBeforeReview / TICKS_PER_DAY));
  let interval = Math.max(1, originalInterval);
  if (response === 0 /* Easy */) {
    ease += 20;
    interval = (interval + delayedBeforeReviewDays) * ease / 100;
    interval *= settings.easyBonus;
  } else if (response === 1 /* Good */) {
    interval = (interval + delayedBeforeReviewDays / 2) * ease / 100;
  } else if (response === 2 /* Hard */) {
    ease = Math.max(130, ease - 20);
    interval = Math.max(
      1,
      (interval + delayedBeforeReviewDays / 4) * settings.lapsesIntervalChange
    );
  } else if (response === 3 /* Again */) {
    ease = Math.max(130, ease - 20);
    interval = 0;
  }
  if (settings.loadBalance && dueDateHistogram !== void 0) {
    interval = Math.round(interval);
    if (interval > 7) {
      let fuzz;
      if (interval <= 21) fuzz = 1;
      else if (interval <= 180) fuzz = Math.min(3, Math.floor(interval * 0.05));
      else fuzz = Math.min(7, Math.floor(interval * 0.025));
      interval = dueDateHistogram.findLeastUsedIntervalOverRange(interval, fuzz);
    }
  }
  interval = Math.min(interval, settings.maximumInterval);
  interval = Math.round(interval * 10) / 10;
  return { interval, ease };
}
function textInterval(interval, isMobile) {
  if (interval === null || interval === void 0) {
    return t("NEW");
  }
  const m2 = Math.round(interval / 3.04375) / 10, y2 = Math.round(interval / 36.525) / 10;
  if (isMobile) {
    if (m2 < 1) return t("DAYS_STR_IVL_MOBILE", { interval });
    else if (y2 < 1) return t("MONTHS_STR_IVL_MOBILE", { interval: m2 });
    else return t("YEARS_STR_IVL_MOBILE", { interval: y2 });
  } else {
    if (m2 < 1) return t("DAYS_STR_IVL", { interval });
    else if (y2 < 1) return t("MONTHS_STR_IVL", { interval: m2 });
    else return t("YEARS_STR_IVL", { interval: y2 });
  }
}

// src/scheduling/algorithms/schedule-display.ts
function formatScheduleInterval(schedule, isMobile) {
  if (!schedule || schedule.interval >= 1 || !schedule.dueDate) {
    return textInterval(schedule == null ? void 0 : schedule.interval, isMobile);
  }
  const diffMs = Math.max(0, schedule.dueDateAsUnix - globalDateProvider.now.valueOf());
  const totalMinutes = Math.max(1, Math.ceil(diffMs / (60 * 1e3)));
  if (totalMinutes < 60) {
    return isMobile ? `${totalMinutes}m` : `${totalMinutes} min`;
  }
  const totalHours = Math.max(1, Math.ceil(totalMinutes / 60));
  return isMobile ? `${totalHours}h` : `${totalHours} hr`;
}

// src/ui/sr-button.tsx
var import_obsidian3 = require("obsidian");
var SRButtonComponent = class extends import_obsidian3.ButtonComponent {
  constructor(container, props) {
    super(container);
    this.setClass("sr-button");
    if (props) {
      if (props.classNames) this.buttonEl.addClasses(props.classNames);
      if (props.icon) this.setIcon(props.icon);
      if (props.tooltip) this.setTooltip(props.tooltip);
      if (props.tooltip) this.buttonEl.setAttribute("aria-label", props.tooltip);
      if (props.text) this.setButtonText(props.text);
      if (props.onClick) this.onClick(props.onClick);
    }
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/response-section/sr-response-button.tsx
var SRResponseButtonComponent = class extends SRButtonComponent {
  constructor(container, props) {
    var _a2;
    super(container, {
      classNames: ["sr-response-button", ...(_a2 = props.classNames) != null ? _a2 : []],
      icon: props.icon,
      tooltip: props.tooltip,
      text: props.text,
      onClick: props.onClick
    });
    this.buttonEl.setText("");
    this.smallText = this.buttonEl.createSpan();
    this.smallText.addClass("sr-small-text");
    this.largeText = this.buttonEl.createSpan();
    this.largeText.addClass("sr-large-text");
    if (props.text) {
      this.smallText.setText(props.text);
      this.largeText.setText(props.text);
    }
  }
  setSmallText(text) {
    this.smallText.setText(text);
  }
  setLargeText(text) {
    this.largeText.setText(text);
  }
};

// src/utils/platform-detector.ts
function EmulatedPlatform() {
  return {
    isDesktop: DEBUG_MODE_ENABLED && !activeDocument.body.hasClass("emulate-mobile"),
    isMobile: DEBUG_MODE_ENABLED && activeDocument.body.hasClass("emulate-mobile"),
    isPhone: DEBUG_MODE_ENABLED && activeDocument.body.hasClass("emulate-mobile") && activeDocument.body.hasClass("is-phone"),
    isTablet: DEBUG_MODE_ENABLED && activeDocument.body.hasClass("emulate-mobile") && activeDocument.body.hasClass("is-tablet"),
    isEmulated: DEBUG_MODE_ENABLED && activeDocument.body.hasClass("emulate-mobile")
  };
}

// src/ui/obsidian-ui-components/content-container/card-container/response-section/response-section.tsx
var ResponseSectionComponent = class {
  constructor(container, settings, showAnswer, processReview) {
    this.responseEl = container.createDiv();
    this.responseEl.addClass("sr-response");
    this.answerButton = new SRResponseButtonComponent(this.responseEl, {
      classNames: ["sr-bg-blue", "sr-show-answer-button"],
      text: t("SHOW_ANSWER"),
      onClick: () => {
        showAnswer();
      }
    });
    this.againButton = new SRResponseButtonComponent(this.responseEl, {
      classNames: ["sr-bg-red", "sr-again-button", "sr-is-hidden"],
      text: settings.flashcardAgainText,
      onClick: async () => {
        await processReview(3 /* Again */);
      }
    });
    this.hardButton = new SRResponseButtonComponent(this.responseEl, {
      classNames: ["sr-bg-yellow", "sr-hard-button", "sr-is-hidden"],
      text: settings.flashcardHardText,
      onClick: async () => {
        await processReview(2 /* Hard */);
      }
    });
    this.goodButton = new SRResponseButtonComponent(this.responseEl, {
      classNames: ["sr-bg-blue", "sr-good-button", "sr-is-hidden"],
      text: settings.flashcardGoodText,
      onClick: async () => {
        await processReview(1 /* Good */);
      }
    });
    this.easyButton = new SRResponseButtonComponent(this.responseEl, {
      classNames: ["sr-bg-green", "sr-easy-button", "sr-is-hidden"],
      text: settings.flashcardEasyText,
      onClick: async () => {
        await processReview(0 /* Easy */);
      }
    });
  }
  resetResponseButtons() {
    if (this.responseEl.hasClass("sr-is-hidden")) {
      this.responseEl.removeClass("sr-is-hidden");
    }
    this.answerButton.buttonEl.removeClass("sr-is-hidden");
    this.againButton.buttonEl.addClass("sr-is-hidden");
    this.hardButton.buttonEl.addClass("sr-is-hidden");
    this.goodButton.buttonEl.addClass("sr-is-hidden");
    this.easyButton.buttonEl.addClass("sr-is-hidden");
  }
  hideAllButtons() {
    if (!this.responseEl.hasClass("sr-is-hidden")) {
      this.responseEl.addClass("sr-is-hidden");
    }
    this.answerButton.buttonEl.addClass("sr-is-hidden");
    this.againButton.buttonEl.addClass("sr-is-hidden");
    this.hardButton.buttonEl.addClass("sr-is-hidden");
    this.goodButton.buttonEl.addClass("sr-is-hidden");
    this.easyButton.buttonEl.addClass("sr-is-hidden");
  }
  showRatingButtons(reviewMode, againButtonText, hardButtonText, goodButtonText, easyButtonText, showIntervalInReviewButtons, determineButtonSchedule) {
    if (this.responseEl.hasClass("sr-is-hidden")) {
      this.responseEl.removeClass("sr-is-hidden");
    }
    this.answerButton.buttonEl.addClass("sr-is-hidden");
    if (reviewMode === 0 /* Cram */) {
      this.responseEl.addClass("is-cram");
      this.againButton.setButtonText(`${againButtonText}`);
      this.easyButton.setButtonText(`${easyButtonText}`);
      if (this.againButton.buttonEl.hasClass("sr-is-hidden")) {
        this.againButton.buttonEl.removeClass("sr-is-hidden");
      }
      if (this.easyButton.buttonEl.hasClass("sr-is-hidden")) {
        this.easyButton.buttonEl.removeClass("sr-is-hidden");
      }
      if (!this.goodButton.buttonEl.hasClass("sr-is-hidden")) {
        this.goodButton.buttonEl.addClass("sr-is-hidden");
      }
      if (!this.hardButton.buttonEl.hasClass("sr-is-hidden")) {
        this.hardButton.buttonEl.addClass("sr-is-hidden");
      }
    } else {
      if (this.responseEl.hasClass("is-cram")) this.responseEl.removeClass("is-cram");
      this.againButton.buttonEl.removeClass("sr-is-hidden");
      this.hardButton.buttonEl.removeClass("sr-is-hidden");
      this.goodButton.buttonEl.removeClass("sr-is-hidden");
      this.easyButton.buttonEl.removeClass("sr-is-hidden");
      this._setupEaseButton(
        this.againButton,
        againButtonText,
        determineButtonSchedule(3 /* Again */),
        showIntervalInReviewButtons
      );
      this._setupEaseButton(
        this.hardButton,
        hardButtonText,
        determineButtonSchedule(2 /* Hard */),
        showIntervalInReviewButtons
      );
      this._setupEaseButton(
        this.goodButton,
        goodButtonText,
        determineButtonSchedule(1 /* Good */),
        showIntervalInReviewButtons
      );
      this._setupEaseButton(
        this.easyButton,
        easyButtonText,
        determineButtonSchedule(0 /* Easy */),
        showIntervalInReviewButtons
      );
    }
  }
  _setupEaseButton(button, buttonName, schedule, showInterval) {
    if (showInterval) {
      button.setSmallText(formatScheduleInterval(schedule, true));
      button.setLargeText(`${buttonName} - ${formatScheduleInterval(schedule, false)}`);
      if (EmulatedPlatform().isMobile || import_obsidian4.Platform.isMobile) {
        if (button.buttonEl.hasClass("sr-show-large-text")) {
          button.buttonEl.removeClass("sr-show-large-text");
        }
        if (!button.buttonEl.hasClass("sr-show-small-text")) {
          button.buttonEl.addClass("sr-show-small-text");
        }
      } else {
        if (button.buttonEl.hasClass("sr-show-small-text")) {
          button.buttonEl.removeClass("sr-show-small-text");
        }
        if (!button.buttonEl.hasClass("sr-show-large-text")) {
          button.buttonEl.addClass("sr-show-large-text");
        }
      }
    } else {
      if (button.buttonEl.hasClass("sr-show-small-text")) {
        button.buttonEl.removeClass("sr-show-small-text");
      }
      if (!button.buttonEl.hasClass("sr-show-large-text")) {
        button.buttonEl.addClass("sr-show-large-text");
      }
      button.setLargeText(buttonName);
    }
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar.tsx
var import_obsidian8 = require("obsidian");

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/deck-info/deck-info.tsx
var import_obsidian6 = require("obsidian");

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/deck-info/counter-component.tsx
var import_obsidian5 = require("obsidian");
var CounterComponent = class {
  constructor(parentEl, iconId, classNames) {
    this.counterEl = parentEl.createDiv();
    this.counterEl.addClass("sr-counter-wrapper");
    classNames.forEach((className) => {
      this.counterEl.addClass(className);
    });
    this.counterTextEl = this.counterEl.createDiv();
    this.counterTextEl.addClass("sr-counter");
    this.counterIconEl = this.counterEl.createDiv();
    this.counterIconEl.addClass("sr-counter-icon");
    (0, import_obsidian5.setIcon)(this.counterIconEl, iconId);
  }
  setText(text) {
    this.counterTextEl.setText(text);
  }
  hasClass(className) {
    return this.counterEl.hasClass(className);
  }
  addClass(className) {
    this.counterEl.addClass(className);
  }
  removeClass(className) {
    this.counterEl.removeClass(className);
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/deck-info/progress-counter-component.tsx
var ProgressCounterComponent = class extends CounterComponent {
  constructor(parentEl, iconId, progress = 0, total = 0, classNames = []) {
    super(parentEl, iconId, classNames);
    this.setProgress(progress, total);
  }
  setProgress(progress, total) {
    this.setText(`${progress}/${total}`);
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/deck-info/deck-info.tsx
var DeckInfoComponent = class {
  constructor(parentEl) {
    this.deckInfoContainer = parentEl.createDiv();
    this.deckInfoContainer.addClass("sr-info-section");
    this.chosenDeckInfo = this.deckInfoContainer.createDiv();
    this.chosenDeckInfo.addClass("sr-deck-info");
    this.chosenDeckInfo.addClass("sr-bg-blue");
    this.chosenDeckInfo.addClass("sr-chosen-deck-info");
    this.chosenDeckName = this.chosenDeckInfo.createDiv();
    this.chosenDeckName.addClass("sr-deck-name");
    this.chosenDeckCounterDivider = this.chosenDeckInfo.createDiv();
    this.chosenDeckCounterDivider.addClass("sr-divider");
    this.chosenDeckCardCounter = new ProgressCounterComponent(
      this.chosenDeckInfo,
      "credit-card",
      0,
      0
    );
    this.chosenDeckSubDeckCounter = new ProgressCounterComponent(
      this.chosenDeckInfo,
      "layers",
      0,
      0
    );
    this.deckPointer = this.deckInfoContainer.createDiv();
    (0, import_obsidian6.setIcon)(this.deckPointer, "chevron-right");
    this.deckPointer.addClass("sr-deck-pointer");
    this.currentDeckInfo = this.deckInfoContainer.createDiv();
    this.currentDeckInfo.addClass("sr-deck-info");
    this.currentDeckInfo.addClass("sr-bg-blue");
    this.currentDeckInfo.addClass("sr-current-deck-info");
    this.currentDeckName = this.currentDeckInfo.createDiv();
    this.currentDeckName.addClass("sr-deck-name");
    this.currentDeckCounterDivider = this.currentDeckInfo.createDiv();
    this.currentDeckCounterDivider.addClass("sr-divider");
    this.currentDeckCardCounter = new ProgressCounterComponent(
      this.currentDeckInfo,
      "credit-card",
      0,
      0
    );
  }
  updateInfo(chosenDeckName, totalCardsInChosenDeck, cardProgressInChosenDeck, totalDecksInChosenDeck, deckProgressInChosenDeck, currentDeckName, currentDeckTotalCardsInDeck, cardProgressInCurrentDeck, isTotallyRandom) {
    this.chosenDeckName.setText(chosenDeckName);
    this.chosenDeckCardCounter.setProgress(cardProgressInChosenDeck, totalCardsInChosenDeck);
    this.chosenDeckSubDeckCounter.setProgress(deckProgressInChosenDeck, totalDecksInChosenDeck);
    this.currentDeckName.setText(currentDeckName);
    this.currentDeckCardCounter.setProgress(
      cardProgressInCurrentDeck,
      currentDeckTotalCardsInDeck
    );
    const hideCurrentDeckInfo = chosenDeckName === currentDeckName || totalDecksInChosenDeck === 1;
    const hideCurrentDeckCardCounter = isTotallyRandom;
    const hideSubdeckCounter = totalDecksInChosenDeck === 1;
    const hideChosenDeckName = !hideCurrentDeckInfo;
    const hideDeckPointer = hideCurrentDeckInfo;
    const hideChosenDeckDivider = hideChosenDeckName;
    const hideCurrentDeckDivider = hideCurrentDeckCardCounter;
    if (hideChosenDeckName) {
      if (!this.chosenDeckName.hasClass("sr-is-hidden")) {
        this.chosenDeckName.addClass("sr-is-hidden");
      }
    } else {
      if (this.chosenDeckName.hasClass("sr-is-hidden")) {
        this.chosenDeckName.removeClass("sr-is-hidden");
      }
    }
    if (hideChosenDeckDivider) {
      if (!this.chosenDeckCounterDivider.hasClass("sr-is-hidden")) {
        this.chosenDeckCounterDivider.addClass("sr-is-hidden");
      }
    } else {
      if (this.chosenDeckCounterDivider.hasClass("sr-is-hidden")) {
        this.chosenDeckCounterDivider.removeClass("sr-is-hidden");
      }
    }
    if (hideSubdeckCounter) {
      if (!this.chosenDeckSubDeckCounter.hasClass("sr-is-hidden")) {
        this.chosenDeckSubDeckCounter.addClass("sr-is-hidden");
      }
    } else {
      if (this.chosenDeckSubDeckCounter.hasClass("sr-is-hidden")) {
        this.chosenDeckSubDeckCounter.removeClass("sr-is-hidden");
      }
    }
    if (hideDeckPointer) {
      if (!this.deckPointer.hasClass("sr-is-hidden")) {
        this.deckPointer.addClass("sr-is-hidden");
      }
    } else {
      if (this.deckPointer.hasClass("sr-is-hidden")) {
        this.deckPointer.removeClass("sr-is-hidden");
      }
    }
    if (hideCurrentDeckInfo) {
      if (!this.currentDeckInfo.hasClass("sr-is-hidden")) {
        this.currentDeckInfo.addClass("sr-is-hidden");
      }
    } else {
      if (this.currentDeckInfo.hasClass("sr-is-hidden")) {
        this.currentDeckInfo.removeClass("sr-is-hidden");
      }
    }
    if (hideCurrentDeckDivider) {
      if (!this.currentDeckCounterDivider.hasClass("sr-is-hidden")) {
        this.currentDeckCounterDivider.addClass("sr-is-hidden");
      }
    } else {
      if (this.currentDeckCounterDivider.hasClass("sr-is-hidden")) {
        this.currentDeckCounterDivider.removeClass("sr-is-hidden");
      }
    }
    if (hideCurrentDeckCardCounter) {
      if (!this.currentDeckCardCounter.hasClass("sr-is-hidden")) {
        this.currentDeckCardCounter.addClass("sr-is-hidden");
      }
    } else {
      if (this.currentDeckCardCounter.hasClass("sr-is-hidden")) {
        this.currentDeckCardCounter.removeClass("sr-is-hidden");
      }
    }
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/back-button.tsx
var BackButtonComponent = class extends SRButtonComponent {
  constructor(container, backToDeck, classNames) {
    super(container, {
      classNames: ["sr-back-button", ...classNames != null ? classNames : []],
      icon: "arrow-left",
      tooltip: t("BACK"),
      onClick: async () => {
        await backToDeck();
      }
    });
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/card-menu-button.tsx
var import_obsidian7 = require("obsidian");

// src/ui/obsidian-ui-components/content-container/menu-button.tsx
var MenuButtonComponent = class extends SRButtonComponent {
  constructor(container, openMenu, classNames) {
    super(container, {
      classNames: ["sr-menu-dots-button", ...classNames != null ? classNames : []],
      icon: "ellipsis-vertical",
      tooltip: t("OPEN_MENU"),
      onClick: (evt) => {
        openMenu(evt);
      }
    });
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/card-menu-button.tsx
var CardMenuButtonComponent = class extends MenuButtonComponent {
  constructor(container, isExtended, showDeleteButton, isModal, isResetButtonDisabled, deleteCurrentCard, editClickHandler, jumpToCurrentCard, displayCurrentCardInfoNotice, skipCurrentCard, onOpenResetModalClick, closeModal, classNames) {
    super(
      container,
      (evt) => {
        const cardMenu = new import_obsidian7.Menu();
        this.buildMenu(
          cardMenu,
          showDeleteButton,
          isModal,
          isExtended,
          editClickHandler,
          onOpenResetModalClick,
          skipCurrentCard,
          jumpToCurrentCard,
          displayCurrentCardInfoNotice,
          deleteCurrentCard,
          closeModal
        );
        cardMenu.showAtMouseEvent(evt);
      },
      classNames
    );
    this.isResetButtonDisabled = isResetButtonDisabled;
  }
  setResetButtonDisabled(disabled) {
    this.isResetButtonDisabled = disabled;
  }
  buildMenu(cardMenu, showDeleteButton, isModal, isExtended, editClickHandler, onOpenResetModalClick, skipCurrentCard, jumpToCurrentCard, displayCurrentCardInfoNotice, deleteCurrentCard, closeModal) {
    if (isExtended) {
      cardMenu.addItem((item) => {
        item.setTitle(t("EDIT_CARD")).setIcon("pencil").onClick(() => {
          editClickHandler();
        });
      });
      cardMenu.addItem((item) => {
        item.setTitle(t("RESET_CARD_PROGRESS")).setIcon("reset").onClick(() => {
          onOpenResetModalClick();
        }).setDisabled(this.isResetButtonDisabled);
      });
      cardMenu.addItem((item) => {
        item.setTitle(t("SKIP")).setIcon("chevrons-right").onClick(() => {
          skipCurrentCard();
        });
      });
    }
    if (isModal) {
      cardMenu.addItem((item) => {
        item.setTitle(t("OPEN_IN_BACKGROUND")).setIcon("send-to-back").onClick(async () => {
          await jumpToCurrentCard();
        });
      });
      cardMenu.addItem((item) => {
        item.setTitle(t("JUMP_TO_AND_CLOSE")).setIcon("arrow-up-right").onClick(async () => {
          await jumpToCurrentCard();
          if (closeModal) {
            closeModal();
          }
        });
      });
    } else {
      cardMenu.addItem((item) => {
        item.setTitle(t("JUMP_TO")).setIcon("arrow-up-right").onClick(async () => {
          await jumpToCurrentCard();
        });
      });
    }
    cardMenu.addItem((item) => {
      item.setTitle(t("VIEW_CARD_INFO")).setIcon("info").onClick(() => {
        displayCurrentCardInfoNotice();
      });
    });
    if (showDeleteButton) {
      cardMenu.addItem((item) => {
        item.setTitle(t("DELETE_CARD")).setIcon("trash").onClick(() => {
          deleteCurrentCard();
        });
      });
    }
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/edit-button.tsx
var EditButtonComponent = class extends SRButtonComponent {
  constructor(container, editClickHandler, classNames) {
    super(container, {
      classNames: ["sr-edit-button", ...classNames != null ? classNames : []],
      icon: "edit",
      tooltip: t("EDIT_CARD"),
      onClick: () => {
        editClickHandler();
      }
    });
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/reset-button.tsx
var ResetButtonComponent = class extends SRButtonComponent {
  constructor(container, onOpenResetModalClick, classNames) {
    super(container, {
      classNames: ["sr-reset-button", "mod-warning", ...classNames != null ? classNames : []],
      icon: "history",
      tooltip: t("RESET_CARD_PROGRESS"),
      onClick: onOpenResetModalClick
    });
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/skip-button.tsx
var SkipButtonComponent = class extends SRButtonComponent {
  constructor(container, skipClickHandler, classNames) {
    super(container, {
      classNames: ["sr-skip-button", ...classNames != null ? classNames : []],
      icon: "chevrons-right",
      tooltip: t("SKIP"),
      onClick: () => {
        skipClickHandler();
      }
    });
  }
};

// src/ui/obsidian-ui-components/content-container/modal-close-button.tsx
var ModalCloseButtonComponent = class extends SRButtonComponent {
  constructor(container, closeModal, classNames) {
    super(container, {
      classNames: ["sr-modal-close-button", ...classNames != null ? classNames : []],
      icon: "x",
      tooltip: t("CLOSE"),
      onClick: () => {
        closeModal();
      }
    });
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar.tsx
var CardToolbarComponent = class {
  constructor(parentEl, showDeleteButton, deleteCurrentCard, backToDeckHandler, editClickHandler, jumpToCurrentCard, displayCurrentCardInfoNotice, skipCurrentCard, onOpenResetModalClick, closeModal) {
    this.toolbar = parentEl.createDiv();
    this.toolbar.addClass("sr-card-toolbar");
    const isModal = closeModal !== void 0;
    new BackButtonComponent(this.toolbar, async () => await backToDeckHandler(), [
      (EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone) && isModal ? "mod-raised" : "clickable-icon"
    ]);
    const centerSpacer = this.toolbar.createDiv();
    centerSpacer.addClass("sr-flex-spacer");
    centerSpacer.addClass("sr-center-spacer");
    this.infoSection = new DeckInfoComponent(this.toolbar);
    this.toolbar.createDiv().addClass("sr-flex-spacer");
    new EditButtonComponent(
      this.toolbar,
      editClickHandler,
      EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone ? ["mod-raised"] : ["clickable-icon"]
    );
    this.resetButton = new ResetButtonComponent(
      this.toolbar,
      onOpenResetModalClick,
      EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone ? ["mod-raised"] : ["clickable-icon"]
    );
    this.resetButton.setDisabled(true);
    new SkipButtonComponent(
      this.toolbar,
      () => skipCurrentCard(),
      EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone ? ["mod-raised"] : ["clickable-icon"]
    );
    this.toolbar.createDiv("sr-divider");
    this.shortMenuButton = new CardMenuButtonComponent(
      this.toolbar,
      false,
      // isExtended = false
      showDeleteButton,
      isModal,
      this.resetButton.disabled,
      deleteCurrentCard,
      editClickHandler,
      jumpToCurrentCard,
      displayCurrentCardInfoNotice,
      skipCurrentCard,
      onOpenResetModalClick,
      closeModal,
      EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone ? ["mod-raised", "sr-short-menu-button"] : ["clickable-icon", "sr-short-menu-button"]
    );
    this.extendedMenuButton = new CardMenuButtonComponent(
      this.toolbar,
      true,
      // isExtended = true
      showDeleteButton,
      isModal,
      this.resetButton.disabled,
      deleteCurrentCard,
      editClickHandler,
      jumpToCurrentCard,
      displayCurrentCardInfoNotice,
      skipCurrentCard,
      onOpenResetModalClick,
      closeModal,
      EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone ? ["mod-raised", "sr-extended-menu-button"] : ["clickable-icon", "sr-extended-menu-button"]
    );
    if (closeModal === void 0) return;
    const closeButtonClasses = [
      EmulatedPlatform().isPhone || import_obsidian8.Platform.isPhone ? "mod-raised" : "clickable-icon"
    ];
    new ModalCloseButtonComponent(this.toolbar, closeModal, closeButtonClasses);
  }
  /**
   * Updates the deck info section
   * @param chosenDeck - The chosen deck
   * @param currentDeck - The current deck
   * @param chosenDeckStats - The stats of the chosen deck
   * @param currentDeckStats - The stats of the current deck
   * @param totalCardsInSession - The total number of cards in the session
   * @param totalDecksInSession - The total number of decks in the session
   * @param currentDeckTotalCardsInQueue - The total number of cards in the current deck
   * @param settings - The settings object
   */
  updateInfo(chosenDeck, currentDeck, chosenDeckStats, currentDeckStats, totalCardsInSession, totalDecksInSession, currentDeckTotalCardsInQueue, flashcardCardOrder) {
    this.infoSection.updateInfo(
      chosenDeck.deckName,
      totalCardsInSession,
      totalCardsInSession - chosenDeckStats.cardsInQueueCount,
      totalDecksInSession,
      totalDecksInSession - chosenDeckStats.decksInQueueOfThisDeckCount,
      currentDeck.deckName,
      currentDeckTotalCardsInQueue,
      currentDeckTotalCardsInQueue - currentDeckStats.cardsInQueueOfThisDeckCount,
      flashcardCardOrder === "EveryCardRandomDeckAndCard"
    );
  }
  /**
   * Sets the reset button disabled state
   * @param disabled - The disabled state
   */
  setResetButtonDisabled(disabled) {
    this.resetButton.buttonEl.toggleClass("mod-disabled", disabled);
    this.extendedMenuButton.setResetButtonDisabled(disabled);
    this.shortMenuButton.setResetButtonDisabled(disabled);
  }
};

// src/ui/obsidian-ui-components/modals/confirmation-modal.tsx
var import_obsidian9 = require("obsidian");
var ConfirmationModal = class extends import_obsidian9.Modal {
  /**
   * Creates a confirmation modal.
   * @param app - The Obsidian app instance.
   * @param title - Title of the modal.
   * @param description - Description text in the modal body.
   * @param confirmationMessage - Notice message to display upon confirmation.
   * @param onConfirm - Callback function to execute upon confirmation.
   */
  constructor(app, title, description, confirmationMessage, onConfirm) {
    super(app);
    this.setTitle(title);
    this.titleEl.addClass("sr-confirmation-modal-header");
    this.setContent(description);
    this.contentEl.addClass("sr-confirmation-modal-content");
    new import_obsidian9.Setting(this.contentEl).setClass("sr-confirmation-modal-button-container").addButton(
      (button) => button.setButtonText(t("CONFIRM")).setClass("mod-warning").onClick(async () => {
        if (confirmationMessage) {
          new import_obsidian9.Notice(confirmationMessage);
        }
        if (onConfirm) {
          await onConfirm();
        }
        this.close();
      })
    ).addButton(
      (button) => button.setButtonText(t("CANCEL")).onClick(() => {
        this.close();
      })
    );
  }
};

// src/utils/escape-html.ts
function escapeHtml(s2) {
  return s2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
}

// src/utils/renderers.ts
var import_obsidian10 = require("obsidian");
var RenderMarkdownWrapper = class {
  constructor(app, plugin, notePath) {
    this.app = app;
    this.notePath = notePath;
    this.plugin = plugin;
  }
  async renderMarkdownWrapper(markdownString, containerEl, textDirection, recursiveDepth = 0) {
    if (recursiveDepth > 4) return;
    let el;
    if (textDirection === 2 /* Rtl */) {
      el = containerEl.createDiv();
      el.setAttribute("dir", "rtl");
    } else el = containerEl;
    if (!el.hasClass("markdown-rendered")) {
      el.addClass("markdown-rendered");
    }
    const renderChild = new import_obsidian10.MarkdownRenderChild(el);
    this.plugin.addChild(renderChild);
    await import_obsidian10.MarkdownRenderer.render(this.app, markdownString, el, this.notePath, renderChild);
    el.findAll(".internal-link").forEach((el2) => {
      el2.addEventListener("click", (e2) => {
        e2.preventDefault();
        e2.stopPropagation();
        const href = el2.getAttr("href") || el2.getAttr("data-href");
        if (href) {
          void this.app.workspace.openLinkText(href, this.notePath, true);
          return true;
        }
        return false;
      });
      el2.addEventListener("mouseover", (ev) => {
        const href = el2.getAttr("href") || el2.getAttr("data-href");
        if (href) {
          this.app.workspace.trigger("hover-link", {
            event: ev,
            source: "preview",
            hoverParent: this.plugin,
            targetEl: el2,
            linktext: href
          });
          return true;
        }
        return false;
      });
    });
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/card-container.tsx
var CardContainer = class {
  constructor(app, plugin, settings, parentEl, deleteCurrentCard, backToDeckHandler, editCardHandler, processReviewHandler, skipCardHandler, showAnswerHandler, jumpToCurrentCardHandler, displayCurrentCardInfoNoticeHandler, closeModal) {
    this.contextSection = null;
    this.pendingClock = null;
    this.pendingResumeTimeout = null;
    this.clozeInputs = null;
    this.clozeAnswers = null;
    this._keydownHandler = (e2) => {
      if (!this.plugin.isInitialized) throw new Error("SR plugin or data not initialized!!!");
      if (this.plugin.uiManager === null) throw new Error("UI manager not initialized!!!");
      if (this.plugin.dataManager.data.settings.useCustomHotkeys || activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT") || this.cardState === 2 /* Closed */ || !this.plugin.uiManager.getSRInFocusState() || import_obsidian11.Platform.isMobile || // No keyboard events on mobile
      EmulatedPlatform().isMobile) {
        return;
      }
      const consumeKeyEvent = () => {
        e2.preventDefault();
        e2.stopPropagation();
      };
      switch (e2.code) {
        case "KeyS":
          this.skipCardHandler();
          consumeKeyEvent();
          break;
        case "KeyJ":
          void this.jumpToCardHandler();
          consumeKeyEvent();
          break;
        case "Enter":
        case "NumpadEnter":
        case "Space":
          if (this.cardState === 0 /* Front */) {
            this.showAnswerHandler();
            consumeKeyEvent();
          } else if (this.cardState === 1 /* Back */) {
            void this.processReviewHandler(1 /* Good */);
            consumeKeyEvent();
          }
          break;
        case "Numpad1":
        case "Digit1":
          if (this.cardState !== 1 /* Back */) {
            break;
          }
          void this.processReviewHandler(2 /* Hard */);
          consumeKeyEvent();
          break;
        case "Numpad2":
        case "Digit2":
          if (this.cardState !== 1 /* Back */) {
            break;
          }
          void this.processReviewHandler(1 /* Good */);
          consumeKeyEvent();
          break;
        case "Numpad3":
        case "Digit3":
          if (this.cardState !== 1 /* Back */) {
            break;
          }
          void this.processReviewHandler(0 /* Easy */);
          consumeKeyEvent();
          break;
        case "Numpad0":
        case "Digit0":
          if (this.cardState !== 1 /* Back */) {
            break;
          }
          void this.processReviewHandler(4 /* Reset */);
          consumeKeyEvent();
          break;
        default:
          break;
      }
    };
    this.app = app;
    this.plugin = plugin;
    this.cardState = 2 /* Closed */;
    this.processReviewHandler = processReviewHandler;
    this.skipCardHandler = skipCardHandler;
    this.showAnswerHandler = showAnswerHandler;
    this.jumpToCardHandler = jumpToCurrentCardHandler;
    this.view = parentEl.createDiv();
    this.view.addClasses(["sr-container", "sr-card-container", "sr-is-hidden"]);
    this.setCustomHotKeyState(settings.useCustomHotkeys);
    this.toolbar = new CardToolbarComponent(
      this.view,
      settings.showDeleteButtonInCardView,
      deleteCurrentCard,
      backToDeckHandler,
      editCardHandler,
      jumpToCurrentCardHandler,
      displayCurrentCardInfoNoticeHandler,
      this.skipCardHandler,
      () => {
        new ConfirmationModal(
          app,
          t("DELETE_SCHEDULING_DATA_OF_CURRENT_CARD"),
          t("CONFIRM_SCHEDULING_DATA_DELETION_OF_CURRENT_CARD"),
          t("SCHEDULING_DATA_DELETION_IN_PROGRESS_OF_CURRENT_CARD"),
          async () => {
            await this.processReviewHandler(4 /* Reset */);
          }
        ).open();
      },
      closeModal
    );
    this.scrollWrapper = this.view.createDiv();
    this.scrollWrapper.addClass("sr-scroll-wrapper");
    this.content = this.scrollWrapper.createDiv();
    this.content.addClass("sr-content");
    this.response = new ResponseSectionComponent(
      this.view,
      settings,
      this.showAnswerHandler,
      this.processReviewHandler
    );
  }
  // #region -> public methods
  /**
   * Shows the FlashcardView if it is hidden
   */
  async openSession(sessionData, settings) {
    if (!this.view.hasClass("sr-is-hidden")) {
      return;
    }
    await this.drawCardFront(sessionData, settings);
    this.view.removeClass("sr-is-hidden");
    activeDocument.addEventListener("keydown", this._keydownHandler);
  }
  /**
   * Hides the FlashcardView if it is visible
   */
  closeSession() {
    if (this.view.hasClass("sr-is-hidden")) {
      return;
    }
    if (this.pendingResumeTimeout !== null) {
      window.clearTimeout(this.pendingResumeTimeout);
      this.pendingResumeTimeout = null;
    }
    this.cardState = 2 /* Closed */;
    activeDocument.removeEventListener("keydown", this._keydownHandler);
    this.view.addClass("sr-is-hidden");
  }
  /**
   * Blocks the key input to the FlashcardView
   *
   * @param block
   */
  blockKeyInput(block) {
    if (block) {
      activeDocument.addEventListener("keydown", this._keydownHandler);
    } else {
      activeDocument.removeEventListener("keydown", this._keydownHandler);
    }
  }
  async drawCardFront(sessionData, settings) {
    this.toolbar.setResetButtonDisabled(true);
    this.cardState = sessionData.cardData.currentCardState;
    this._updateInfoBar(sessionData, settings.flashcardCardOrder);
    this.content.empty();
    if (settings.showContextInCards) {
      this.contextSection = new ContextSectionComponent(this.content);
      this.contextSection.updateCardContext(
        settings.showContextInCards,
        sessionData.currentQuestion,
        sessionData.currentNote
      );
    }
    const wrapper = new RenderMarkdownWrapper(
      this.app,
      this.plugin,
      sessionData.currentNote.filePath
    );
    await wrapper.renderMarkdownWrapper(
      sessionData.cardData.currentCard.front.trimStart(),
      this.content,
      sessionData.currentQuestion.questionText.textDirection
      // sessionData.cardData.currentCardState
    );
    this.content.scrollTop = 0;
    this.response.resetResponseButtons();
    this._setupClozeInputListeners();
    if (sessionData.currentQuestion.questionType === 4 /* Cloze */) {
      const firstInput = activeDocument.querySelector(".cloze-input");
      if (firstInput) {
        firstInput.focus();
      }
    }
  }
  drawPendingState(nextPendingDueUnix) {
    this.toolbar.setResetButtonDisabled(true);
    this.cardState = 0 /* Front */;
    this.content.empty();
    this.response.hideAllButtons();
    this.pendingClock = this.content.createDiv({
      cls: "sr-centered"
    });
    const updatePendingClock = () => {
      var _a2;
      const startTime = (0, import_moment3.default)();
      const endTime = (0, import_moment3.default)(nextPendingDueUnix);
      const duration = import_moment3.default.duration(endTime.diff(startTime));
      const hours = Math.floor(duration.asHours());
      const minutes = duration.minutes();
      const seconds = duration.seconds();
      const formatted = `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
      (_a2 = this.pendingClock) == null ? void 0 : _a2.setText(
        `Waiting for the next FSRS review step. Next card due in ${formatted} (HH:mm:ss).`
      );
      this.pendingResumeTimeout = window.setTimeout(() => {
        updatePendingClock();
      }, 1e3);
    };
    updatePendingClock();
  }
  // #region -> Deck Info
  setCustomHotKeyState(state) {
    if (state) {
      if (!this.view.hasClass("sr-custom-hotkeys")) {
        this.view.addClass("sr-custom-hotkeys");
      }
    } else {
      if (this.view.hasClass("sr-custom-hotkeys")) {
        this.view.removeClass("sr-custom-hotkeys");
      }
    }
  }
  _updateInfoBar(sessionData, flashcardCardOrder) {
    if (sessionData.deckData.chosenDeck === null || sessionData.deckData.currentDeck === null)
      return;
    this.toolbar.updateInfo(
      sessionData.deckData.chosenDeck,
      sessionData.deckData.currentDeck,
      sessionData.deckData.chosenDeckStats,
      sessionData.deckData.currentDeckStats,
      sessionData.totalCardsInSession,
      sessionData.totalDecksInSession,
      sessionData.deckData.currentDeckTotalCardsInQueue,
      flashcardCardOrder
    );
  }
  _setupClozeInputListeners() {
    this.clozeInputs = activeDocument.querySelectorAll(".cloze-input");
    this.clozeInputs.forEach((input) => {
      input.addEventListener("keydown", (e2) => {
        if (e2.key === "Enter") {
          e2.preventDefault();
          e2.stopPropagation();
          input.blur();
          this.showAnswerHandler();
        }
      });
    });
  }
  _evaluateClozeAnswers() {
    this.clozeAnswers = activeDocument.querySelectorAll(".cloze-answer");
    if (this.clozeInputs !== null && this.clozeAnswers.length === this.clozeInputs.length) {
      for (let i2 = 0; i2 < this.clozeAnswers.length; i2++) {
        const clozeInput = this.clozeInputs[i2];
        const clozeAnswer = this.clozeAnswers[i2];
        const inputText = clozeInput.value.trim();
        const answerText = clozeAnswer.innerText.trim();
        clozeAnswer.empty();
        const answerElement = clozeAnswer.createSpan({
          text: escapeHtml(inputText),
          cls: "cloze-answer"
        });
        answerElement.setCssProps({
          color: inputText === answerText ? "green" : "red",
          "text-Decoration": inputText === answerText ? "none" : "line-through"
        });
        if (inputText !== answerText) {
          const span = clozeAnswer.createSpan({
            text: escapeHtml(answerText),
            cls: "cloze-answer-wrong"
          });
          span.setCssProps({
            color: "green",
            "text-decoration": "none"
          });
        }
      }
    }
  }
  async drawBack(sessionData, reviewMode, settings, determineButtonSchedule) {
    this.setCustomHotKeyState(settings.useCustomHotkeys);
    this.cardState = sessionData.cardData.currentCardState;
    this.toolbar.setResetButtonDisabled(false);
    if (sessionData.currentQuestion.questionType !== 4 /* Cloze */) {
      const hr = activeDocument.createElement("hr");
      this.content.appendChild(hr);
    } else {
      this.content.empty();
    }
    const wrapper = new RenderMarkdownWrapper(
      this.app,
      this.plugin,
      sessionData.currentNote.filePath
    );
    await wrapper.renderMarkdownWrapper(
      sessionData.cardData.currentCard.back,
      this.content,
      sessionData.currentQuestion.questionText.textDirection
      // sessionData.cardData.currentCardState,
    );
    this._evaluateClozeAnswers();
    this.response.showRatingButtons(
      reviewMode,
      settings.flashcardAgainText,
      settings.flashcardHardText,
      settings.flashcardGoodText,
      settings.flashcardEasyText,
      settings.showIntervalInReviewButtons,
      determineButtonSchedule
    );
    if (this.plugin.uiManager === null) throw new Error("UI manager not initialized!!!");
    this.plugin.uiManager.setSRViewInFocus(true);
    this.response.againButton.buttonEl.focus();
  }
};

// src/ui/obsidian-ui-components/content-container/card-container/toolbar/toolbar-buttons/card-info-notice.tsx
var import_obsidian12 = require("obsidian");
var CardInfoNotice = class extends import_obsidian12.Notice {
  constructor(schedule, notePath) {
    var _a2;
    const currentEaseStr = t("CURRENT_EASE_HELP_TEXT") + ((_a2 = schedule == null ? void 0 : schedule.latestEase) != null ? _a2 : t("NEW"));
    const currentIntervalStr = t("CURRENT_INTERVAL_HELP_TEXT") + formatScheduleInterval(schedule, false);
    const generatedFromStr = t("CARD_GENERATED_FROM", {
      notePath
    });
    super(currentEaseStr + "\n" + currentIntervalStr + "\n" + generatedFromStr);
  }
};

// src/ui/obsidian-ui-components/content-container/deck-container/deck-list.tsx
var import_obsidian13 = require("obsidian");
var DeckListComponent = class {
  constructor(parentEl, startReviewOfDeck) {
    this.startReviewOfDeck = startReviewOfDeck;
    this.scrollWrapper = parentEl.createDiv();
    this.scrollWrapper.addClass("sr-scroll-wrapper");
    this.content = this.scrollWrapper.createDiv();
    this.content.addClass("sr-content");
    this.treeHeaderRow = this.content.createDiv();
    this.treeHeaderRow.addClass("sr-tree-row");
    this.treeHeaderRow.addClass("sr-header-row");
    this.treeHeaderRow.addClass("tree-item");
    this.treeHeaderRow.addClass("sr-tree-item-container");
    this.treeHeaderRowSelf = this.treeHeaderRow.createDiv();
    this.treeHeaderRowSelf.addClass("tree-item-self");
    this.treeHeaderRowSelf.addClass("sr-tree-item-row");
    this.treeHeaderRowInner = this.treeHeaderRowSelf.createDiv("tree-item-inner");
    this.treeHeaderRowText = this.treeHeaderRowInner.createDiv("tag-pane-tag-text");
    this.treeHeaderRowTextSpan = this.treeHeaderRowText.createSpan("tag-pane-tag-self");
    this.treeHeaderRowTextSpan.addClass("sr-tree-row-text");
    this.treeHeaderRowTextSpan.setText("Title");
    this.treeHeaderRowNumbersWrapper = this.treeHeaderRowSelf.createDiv();
    this.treeHeaderRowNumbersWrapper.addClasses([
      "tree-item-flair-outer",
      "sr-tree-stats-container"
    ]);
    this.treeHeaderRowNumbersWrapper.addClass("sr-tree-row-numbers-wrapper");
    this.treeHeaderRowNumbersWrapper.addClass("sr-tree-stats-container");
    this.dueCardsText = this.treeHeaderRowNumbersWrapper.createDiv();
    this.dueCardsText.addClass("sr-tree-numbers-text");
    this.dueCardsText.addClasses([
      "tag-pane-tag-count",
      "tree-item-flair",
      "sr-tree-stats-count",
      "sr-fg-green"
    ]);
    this.dueCardsText.setText(t("DUE"));
    this.newCardsText = this.treeHeaderRowNumbersWrapper.createDiv();
    this.newCardsText.addClass("sr-tree-numbers-text");
    this.newCardsText.addClasses([
      "tag-pane-tag-count",
      "tree-item-flair",
      "sr-tree-stats-count",
      "sr-fg-blue"
    ]);
    this.newCardsText.setText(t("NEW"));
    this.reviewedCardsText = this.treeHeaderRowNumbersWrapper.createDiv();
    this.reviewedCardsText.addClass("sr-tree-numbers-text");
    this.reviewedCardsText.addClasses([
      "tag-pane-tag-count",
      "tree-item-flair",
      "sr-tree-stats-count",
      "sr-fg-yellow"
    ]);
    this.reviewedCardsText.setText(t("SEEN"));
    this.totalCardsText = this.treeHeaderRowNumbersWrapper.createDiv();
    this.totalCardsText.addClass("sr-tree-numbers-text");
    this.totalCardsText.addClasses([
      "tag-pane-tag-count",
      "tree-item-flair",
      "sr-tree-stats-count",
      "sr-fg-red"
    ]);
    this.totalCardsText.setText(t("TOTAL"));
    this.treeContainer = this.content.createDiv("sr-tree-container");
  }
  /**
   * Redraws the deck list.
   * @param startReviewOfDeck - Callback for starting the review of a deck.
   * @param settings - The settings object.
   * @param reviewSequencer - The review sequencer object.
   */
  redraw(reviewSequencer, settings) {
    this.treeContainer.empty();
    const originDeckStats = reviewSequencer.getDeckStats(
      reviewSequencer.originalDeckTree.getTopicPath()
    );
    if (originDeckStats.totalCount === 0) {
      const noDecksToReviewEl = this.treeContainer.createDiv();
      noDecksToReviewEl.addClass("sr-no-decks-to-review");
      noDecksToReviewEl.setText(t("NO_DECKS_TO_REVIEW"));
      return;
    }
    this._crateTreeRow(
      "All Decks",
      originDeckStats,
      0,
      this.treeContainer,
      false,
      reviewSequencer.originalDeckTree,
      this.startReviewOfDeck
    );
    for (const subdeck of reviewSequencer.originalDeckTree.subdecks) {
      this._createTree(
        subdeck,
        this.treeContainer,
        reviewSequencer,
        settings,
        this.startReviewOfDeck
      );
    }
  }
  _createTree(deck, parentEl, reviewSequencer, settings, startReviewOfDeck) {
    const deckStats = reviewSequencer.getDeckStats(deck.getTopicPath());
    const treeRowChildren = this._crateTreeRow(
      deck.deckName,
      deckStats,
      deck.subdecks.length,
      parentEl,
      settings.initiallyExpandAllSubdecksInTree,
      deck,
      startReviewOfDeck
    );
    for (const subdeck of deck.subdecks) {
      this._createTree(
        subdeck,
        treeRowChildren,
        reviewSequencer,
        settings,
        startReviewOfDeck
      );
    }
  }
  _crateTreeRow(deckName, deckStats, numOfSubdecks, parentEl, initiallyExpanded = false, deck = null, startReviewOfDeck = () => {
  }) {
    const disableInteraction = deck === null;
    const treeRow = parentEl.createDiv();
    treeRow.addClass("sr-tree-row");
    treeRow.addClass("tree-item");
    treeRow.addClass("sr-tree-item-container");
    const treeRowSelf = treeRow.createDiv();
    treeRowSelf.addClass("tree-item-self");
    if (!disableInteraction) {
      treeRowSelf.addClass("tag-pane-tag");
    }
    treeRowSelf.addClass("sr-tree-item-row");
    let collapsed = !initiallyExpanded;
    const collapseIconEl = treeRowSelf.createDiv("tree-item-icon collapse-icon");
    (0, import_obsidian13.setIcon)(collapseIconEl, "chevron-down");
    if (collapsed) collapseIconEl.addClass("is-collapsed");
    if (numOfSubdecks === 0) collapseIconEl.setCssProps({ display: "none" });
    const treeRowInner = treeRowSelf.createDiv("tree-item-inner");
    const treeRowInnerText = treeRowInner.createDiv("tag-pane-tag-text");
    const treeRowInnerTextSpan = treeRowInnerText.createSpan("tag-pane-tag-self");
    treeRowInnerTextSpan.setText(deckName);
    const treeRowOuter = treeRowSelf.createDiv();
    treeRowOuter.addClasses(["tree-item-flair-outer", "sr-tree-stats-container"]);
    const treeRowChildren = treeRow.createDiv("tree-item-children");
    treeRowChildren.setCssProps({ display: collapsed ? "none" : "block" });
    if (disableInteraction || deckStats.dueCount === 0 && deckStats.newCount === 0) {
      if (!disableInteraction) {
        treeRowSelf.addClass("is-disabled");
      }
    } else {
      treeRowSelf.addClass("is-clickable");
      collapseIconEl.addEventListener("click", (e2) => {
        if (collapsed) {
          collapseIconEl.removeClass("is-collapsed");
          treeRowChildren.setCssProps({ display: "block" });
        } else {
          collapseIconEl.addClass("is-collapsed");
          treeRowChildren.setCssProps({ display: "none" });
        }
        e2.stopPropagation();
        collapsed = !collapsed;
      });
    }
    if (!disableInteraction) {
      treeRowSelf.addEventListener("click", () => {
        startReviewOfDeck(deck);
      });
    }
    this._createStatsInRow(treeRowOuter, deckStats);
    return treeRowChildren;
  }
  _createStatsInRow(parentEl, deckStats) {
    parentEl.empty();
    this._createStatsContainer(t("DUE_CARDS"), deckStats.dueCount, "sr-bg-green", parentEl);
    this._createStatsContainer(t("NEW_CARDS"), deckStats.newCount, "sr-bg-blue", parentEl);
    const reviewedCards = deckStats.totalCount - deckStats.newCount - deckStats.dueCount;
    this._createStatsContainer(t("SEEN_CARDS"), reviewedCards, "sr-bg-yellow", parentEl);
    this._createStatsContainer(t("TOTAL_CARDS"), deckStats.totalCount, "sr-bg-red", parentEl);
  }
  _createStatsContainer(statsLable, statsNumber, statsClass, statsWrapper) {
    const statsContainer = statsWrapper.createDiv();
    statsContainer.ariaLabel = statsLable;
    statsContainer.addClasses([
      "tag-pane-tag-count",
      "tree-item-flair",
      "sr-tree-stats-count",
      statsClass
    ]);
    statsContainer.setText(statsNumber.toString());
  }
};

// src/ui/obsidian-ui-components/content-container/deck-container/deck-list-header.tsx
var import_obsidian14 = require("obsidian");
var DeckListHeaderComponent = class {
  constructor(parentEl, changeReviewMode, closeModal) {
    this.header = parentEl.createDiv();
    this.header.addClass("sr-deck-list-header");
    this.header.addClass("sr-header");
    this.deckIcon = this.header.createDiv();
    this.deckIcon.addClass("sr-deck-icon");
    (0, import_obsidian14.setIcon)(this.deckIcon, "layers");
    this.title = this.header.createDiv();
    this.title.addClass("sr-title");
    this.title.setText(t("DECKS"));
    this.header.createDiv().addClass("sr-flex-spacer");
    this.reviewModeDropdown = new import_obsidian14.DropdownComponent(this.header);
    const reviewModeOptions = {
      Review: t("REVIEW_MODE"),
      Cram: t("CRAM_MODE")
    };
    this.reviewModeDropdown.addOptions(reviewModeOptions);
    this.reviewModeDropdown.setValue("Review");
    this.reviewModeDropdown.onChange((value) => {
      if (value === void 0) return;
      if (value === "Review") changeReviewMode(1 /* Review */);
      if (value === "Cram") changeReviewMode(0 /* Cram */);
    });
    if (closeModal === void 0) return;
    const closeButtonClasses = [
      "sr-modal-close-button",
      EmulatedPlatform().isPhone || import_obsidian14.Platform.isPhone ? "mod-raised" : "clickable-icon"
    ];
    if (EmulatedPlatform().isPhone || import_obsidian14.Platform.isPhone) {
      closeButtonClasses.push("mod-raised");
      closeButtonClasses.push("clickable-icon");
    }
    new ModalCloseButtonComponent(
      this.header,
      () => closeModal && closeModal(),
      closeButtonClasses
    );
  }
  updateReviewMode(reviewMode) {
    this.reviewModeDropdown.setValue(
      reviewMode === 1 /* Review */ ? "Review" : "Cram"
    );
  }
};

// src/ui/obsidian-ui-components/content-container/deck-container/deck-container.tsx
var DeckContainer = class {
  constructor(parentEl, changeReviewMode, startReviewOfDeck, closeModal) {
    this.containerEl = parentEl.createDiv();
    this.containerEl.addClasses(["sr-container", "sr-deck-container", "sr-is-hidden"]);
    this.deckListHeader = new DeckListHeaderComponent(
      this.containerEl,
      changeReviewMode,
      closeModal
    );
    this.deckList = new DeckListComponent(this.containerEl, startReviewOfDeck);
  }
  /**
   * Shows the DeckListView & rerenders dynamic elements
   */
  showList(reviewSequencer, settings, reviewMode) {
    this.deckListHeader.updateReviewMode(reviewMode);
    this.deckList.redraw(reviewSequencer, settings);
    if (this.containerEl.hasClass("sr-is-hidden")) {
      this.containerEl.removeClass("sr-is-hidden");
    }
  }
  /**
   * Hides the DeckListView
   */
  closeList() {
    if (!this.containerEl.hasClass("sr-is-hidden")) {
      this.containerEl.addClass("sr-is-hidden");
    }
  }
  redrawWithNewData(reviewSequencer, settings) {
    this.deckList.redraw(reviewSequencer, settings);
  }
};

// src/ui/obsidian-ui-components/modals/edit-modal.tsx
var import_obsidian15 = require("obsidian");
var FlashcardEditModal = class _FlashcardEditModal extends import_obsidian15.Modal {
  constructor(app, settings, currentCard, existingText, textDirection) {
    super(app);
    this.resolvePromise = null;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    this.rejectPromise = null;
    this.didSaveChanges = false;
    this.textFront = "";
    this.textBack = "";
    // -> Functions & helpers
    this.saveClickCallback = (_2) => this.save();
    this.cancelClickCallback = (_2) => this.close();
    this.keyListenerCallback = (evt) => {
      if (evt.key === "Tab") {
        evt.preventDefault();
        const textarea = evt.target;
        const currentCaretStartPosition = textarea.selectionStart;
        const currentCaretEndPosition = textarea.selectionEnd;
        const newEndPosition = currentCaretStartPosition + 1;
        textarea.setRangeText("	", currentCaretStartPosition, currentCaretEndPosition);
        textarea.setSelectionRange(newEndPosition, newEndPosition);
      }
      if ((evt.ctrlKey || evt.metaKey) && evt.key === "Enter") {
        evt.preventDefault();
        this.save();
      }
    };
    this.modalText = existingText;
    this.changedText = existingText;
    this.textDirection = textDirection;
    this.currentCard = currentCard;
    this.cardType = this.currentCard.question.questionType;
    this.separator = this.getSeparatorFromCardType(this.cardType, settings);
    if (this.separator !== null) {
      this.textFront = this.currentCard.front;
      this.textBack = this.currentCard.back;
      if (this.cardType === 2 /* MultiLineBasic */ || this.cardType === 3 /* MultiLineReversed */) {
        this.textBack = this.textBack.trimStart();
        this.textFront = this.textFront.trimEnd();
      }
    } else {
      this.textFront = this.modalText;
      this.textBack = "";
    }
    this.waitForClose = new Promise((resolve2, reject) => {
      this.resolvePromise = resolve2;
      this.rejectPromise = reject;
    });
    this.modalEl.addClasses(["sr-modal", "sr-edit-modal"]);
    this.contentEl.empty();
    this.contentEl.addClass("sr-edit-view");
    const title = this.contentEl.createDiv();
    title.setText(t("EDIT_CARD"));
    title.addClass("sr-title");
    this.textAreaFront = this.contentEl.createEl("textarea");
    this.textAreaFront.addClass("sr-input");
    this.textAreaFront.setText(this.textFront);
    this.textAreaFront.addEventListener("keydown", this.keyListenerCallback);
    if (this.textDirection === 2 /* Rtl */) {
      this.textAreaFront.setAttribute("dir", "rtl");
    }
    this.textAreaBack = this.contentEl.createEl("textarea");
    this.textAreaBack.addClass("sr-input");
    if (this.separator === null) {
      this.textAreaBack.addClass("sr-is-hidden");
    } else {
      this.textAreaBack.setText(this.textBack);
      this.textAreaBack.addEventListener("keydown", this.keyListenerCallback);
      if (this.textDirection === 2 /* Rtl */) {
        this.textAreaBack.setAttribute("dir", "rtl");
      }
    }
    const response = this.contentEl.createDiv();
    response.addClass("sr-response");
    const saveButton = new import_obsidian15.ButtonComponent(response);
    saveButton.setClass("sr-response-button");
    saveButton.setClass("sr-save-button");
    saveButton.setClass("sr-bg-green");
    saveButton.setButtonText(t("SAVE"));
    saveButton.onClick((evt) => {
      this.saveClickCallback(evt);
    });
    const button = response.createEl("button");
    button.addClasses(["sr-response-button", "sr-dummy-button"]);
    button.setText("");
    const cancelButton = new import_obsidian15.ButtonComponent(response);
    cancelButton.setClass("sr-response-button");
    cancelButton.setClass("sr-cancel-button");
    cancelButton.setClass("sr-bg-red");
    cancelButton.setButtonText(t("CANCEL"));
    cancelButton.onClick((evt) => {
      this.cancelClickCallback(evt);
    });
    this.open();
  }
  static Prompt(app, settings, currentCard, placeholder, textDirection) {
    const newPromptModal = new _FlashcardEditModal(
      app,
      settings,
      currentCard,
      placeholder,
      textDirection
    );
    return newPromptModal.waitForClose;
  }
  /**
   * Opens the EditModal
   */
  async onOpen() {
    await super.onOpen();
    if (this.textAreaFront !== null) {
      this.textAreaFront.focus();
    }
  }
  /**
   * Closes the EditModal
   */
  onClose() {
    super.onClose();
    this.resolveInput();
    this.removeInputListener();
  }
  save() {
    this.didSaveChanges = true;
    this.changedText = this.textAreaFront.value;
    if (this.separator) {
      if ((this.cardType === 2 /* MultiLineBasic */ || this.cardType === 3 /* MultiLineReversed */) && !this.textAreaFront.value.endsWith("\n")) {
        this.changedText += "\n";
      }
      this.changedText += this.separator;
      if ((this.cardType === 2 /* MultiLineBasic */ || this.cardType === 3 /* MultiLineReversed */) && !this.textAreaBack.value.startsWith("\n")) {
        this.changedText += "\n";
      }
      this.changedText += this.textAreaBack.value;
    }
    this.close();
  }
  resolveInput() {
    if (this.rejectPromise === null || this.resolvePromise === null) return;
    if (!this.didSaveChanges) this.rejectPromise(t("NO_INPUT"));
    else this.resolvePromise(this.changedText);
  }
  removeInputListener() {
    if (this.textAreaFront !== null) {
      this.textAreaFront.removeEventListener("keydown", this.keyListenerCallback);
    }
  }
  getSeparatorFromCardType(cardType, settings) {
    switch (cardType) {
      case 0 /* SingleLineBasic */:
        return settings.singleLineCardSeparator;
      case 1 /* SingleLineReversed */:
        return settings.singleLineReversedCardSeparator;
      case 2 /* MultiLineBasic */:
        return settings.multilineCardSeparator;
      case 3 /* MultiLineReversed */:
        return settings.multilineReversedCardSeparator;
      case 4 /* Cloze */:
        return null;
    }
  }
};

// src/ui/obsidian-ui-components/content-container/content-manager.tsx
var ContentManager = class {
  constructor(app, plugin, reviewQueueLoader, settings, parentEl, closeModal) {
    this.reviewSequencer = null;
    this.sessionData = null;
    this.lastPressedOnProcessReview = 0;
    this.pendingResumeTimeout = null;
    this.app = app;
    this.plugin = plugin;
    this.reviewQueueLoader = reviewQueueLoader;
    this.settings = settings;
    this.reviewMode = reviewQueueLoader.getReviewMode();
    this.uiManager = this.plugin.uiManager;
    this.dataManager = this.plugin.dataManager;
    this.deckContainer = new DeckContainer(
      parentEl,
      this._changeReviewMode.bind(this),
      this._startReviewOfDeck.bind(this),
      closeModal
    );
    this.cardContainer = new CardContainer(
      this.app,
      this.plugin,
      this.settings,
      parentEl,
      this._deleteCurrentCard.bind(this),
      this._showDecksList.bind(this),
      this._doEditQuestionText.bind(this),
      this._processReview.bind(this),
      this._skipCurrentCard.bind(this),
      this._showAnswer.bind(this),
      this._jumpToCurrentCard.bind(this),
      this._displayCurrentCardInfoNotice.bind(this),
      closeModal
    );
  }
  close() {
    this._clearPendingResumeTimeout();
    this.uiManager.setSRViewInFocus(false);
    this.deckContainer.closeList();
    this.cardContainer.closeSession();
    this.uiManager.setUIState(0 /* Closed */);
  }
  async open() {
    this.reviewSequencer = await this.reviewQueueLoader.loadReviewQueue();
    const subdecksWithCardsInQueue = this.reviewSequencer.getSubDecksWithCardsInQueue(
      this.reviewSequencer.originalDeckTree
    );
    let openImmediately = false;
    let deckWithCards = null;
    for (const subdeck of subdecksWithCardsInQueue) {
      const hasNewCards = subdeck.newRepItems.length > 0;
      const hasDueCards = subdeck.dueRepItems.length > 0;
      const hasDueCardsToday = hasDueCards && subdeck.dueRepItems.some((card) => {
        const dueDate = card.scheduleInfo.dueDateAsUnix;
        const nowUnix = globalDateProvider.now.valueOf();
        return dueDate <= nowUnix;
      });
      const hasCardsToday = hasNewCards || hasDueCardsToday;
      if (openImmediately && (hasCardsToday || this.reviewMode === 0 /* Cram */)) {
        openImmediately = false;
        break;
      }
      if (hasCardsToday || this.reviewMode === 0 /* Cram */) {
        openImmediately = true;
        deckWithCards = subdeck;
      }
    }
    if (openImmediately && deckWithCards !== null) {
      await this._reviewDeck(deckWithCards);
    } else {
      await this._showDecksList();
    }
  }
  // MARK: Content Manager
  async _showDecksList(reloadReviewQueue = false) {
    this._clearPendingResumeTimeout();
    if (reloadReviewQueue) {
      this.reviewSequencer = await this.reviewQueueLoader.loadReviewQueue();
    }
    if (this.reviewSequencer === null) return;
    this.cardContainer.closeSession();
    this.uiManager.setUIState(1 /* DeckList */);
    this.deckContainer.showList(this.reviewSequencer, this.settings, this.reviewMode);
  }
  async _reviewDeck(deck) {
    this.deckContainer.closeList();
    this.sessionData = this._getNewSessionData(deck);
    if (this.sessionData === null) return;
    this.uiManager.setUIState(2 /* CardFront */);
    await this.cardContainer.openSession(this.sessionData, this.settings);
  }
  async _showNextCard() {
    if (this.sessionData === null || this.reviewSequencer === null) {
      await this._showDecksList(true);
      return;
    }
    if (!this.reviewSequencer.hasCurrentCard) {
      await this._showDecksList(true);
      return;
    }
    if (this.reviewSequencer.currentDeck === null) {
      await this._showDecksList(true);
      return;
    }
    const chosenDeckStats = this.reviewSequencer.getDeckStats(
      this.sessionData.deckData.chosenDeck.getTopicPath()
    );
    this.sessionData.deckData.chosenDeckStats = chosenDeckStats;
    this.sessionData.deckData.previousDeck = this.sessionData.deckData.currentDeck;
    this.sessionData.deckData.previousDeckStats = this.sessionData.deckData.currentDeckStats;
    this.sessionData.deckData.currentDeck = this.reviewSequencer.currentDeck;
    const currentDeckStats = this.reviewSequencer.getDeckStats(
      this.reviewSequencer.currentDeck.getTopicPath()
    );
    this.sessionData.deckData.currentDeckStats = currentDeckStats;
    if (this.sessionData.deckData.previousDeck !== this.sessionData.deckData.currentDeck) {
      this.sessionData.deckData.currentDeckTotalCardsInQueue = currentDeckStats.cardsInQueueOfThisDeckCount;
    }
    this.sessionData.currentNote = this.reviewSequencer.currentNote;
    this.sessionData.currentQuestion = this.reviewSequencer.currentQuestion;
    this.sessionData.cardData.currentCard = this.reviewSequencer.currentCard;
    this.uiManager.setUIState(2 /* CardFront */);
    this.sessionData.cardData.currentCardState = 0 /* Front */;
    if (this.sessionData.cardData.currentCard !== null && this.sessionData.cardData.currentCard !== void 0) {
      await this.cardContainer.drawCardFront(this.sessionData, this.settings);
    } else {
      await this._showDecksList(true);
    }
  }
  async _showPendingState() {
    if (this.reviewSequencer === null) return;
    this._clearPendingResumeTimeout();
    const nextPendingDueUnix = this.reviewSequencer.nextPendingDueUnix;
    if (nextPendingDueUnix === null) {
      await this._showDecksList(true);
      return;
    }
    this.uiManager.setUIState(2 /* CardFront */);
    this.cardContainer.drawPendingState(nextPendingDueUnix);
    const delayMs = Math.max(0, nextPendingDueUnix - Date.now());
    this.pendingResumeTimeout = window.setTimeout(() => {
      if (this.reviewSequencer === null) return;
      this.reviewSequencer.refreshCurrentDeck();
      void this._showNextCard();
    }, delayMs + 50);
  }
  _getNewSessionData(deck) {
    if (this.reviewSequencer === null) return null;
    const deckStats = this.reviewSequencer.getDeckStats(deck.getTopicPath());
    const totalCardsInSession = deckStats.cardsInQueueCount;
    const totalDecksInSession = deckStats.decksInQueueOfThisDeckCount;
    const currentCardState = 0 /* Front */;
    const currentDeckStats = this.reviewSequencer.getDeckStats(
      this.reviewSequencer.currentDeck.getTopicPath()
    );
    const chosenDeckStats = this.reviewSequencer.getDeckStats(deck.getTopicPath());
    return {
      cardData: {
        currentCard: this.reviewSequencer.currentCard,
        currentCardState
      },
      deckData: {
        chosenDeck: deck,
        currentDeck: this.reviewSequencer.currentDeck,
        previousDeck: null,
        currentDeckTotalCardsInQueue: currentDeckStats.cardsInQueueOfThisDeckCount,
        currentDeckStats,
        previousDeckStats: null,
        chosenDeckStats
      },
      totalCardsInSession,
      totalDecksInSession,
      currentQuestion: this.reviewSequencer.currentQuestion,
      currentNote: this.reviewSequencer.currentNote
    };
  }
  // MARK: Card button handlers
  _deleteCurrentCard() {
    if (this.sessionData === null || this.reviewSequencer === null || this.dataManager.data === null)
      return;
    const timeNow = (0, import_moment4.now)();
    if (this.lastPressedOnProcessReview && timeNow - this.lastPressedOnProcessReview < this.dataManager.data.settings.reviewButtonDelay) {
      return;
    }
    this.lastPressedOnProcessReview = timeNow;
    new ConfirmationModal(
      this.app,
      t("DELETE_CARD"),
      t("DELETE_CARD_CONFIRMATION"),
      t("CANCEL"),
      async () => {
        if (this.sessionData === null || this.reviewSequencer === null) return;
        await this.reviewSequencer.deleteCurrentCardFromNote();
        await this._showNextCard();
      }
    ).open();
  }
  async _showAnswer() {
    if (this.sessionData === null) return;
    const timeNow = (0, import_moment4.now)();
    if (this.lastPressedOnProcessReview && timeNow - this.lastPressedOnProcessReview < this.dataManager.data.settings.reviewButtonDelay) {
      return;
    }
    this.lastPressedOnProcessReview = timeNow;
    this.uiManager.setUIState(3 /* CardBack */);
    this.sessionData.cardData.currentCardState = 1 /* Back */;
    await this.cardContainer.drawBack(
      this.sessionData,
      this.reviewMode,
      this.settings,
      this._determineButtonSchedule.bind(this)
    );
  }
  async _doEditQuestionText() {
    if (this.reviewSequencer === null) return;
    const currentCard = this.reviewSequencer.currentCard;
    const currentQ = this.reviewSequencer.currentQuestion;
    const textPrompt = currentQ.questionText.actualQuestion;
    this.uiManager.setUIState(4 /* EditModal */);
    const editModal = FlashcardEditModal.Prompt(
      this.app,
      this.settings,
      currentCard,
      textPrompt,
      currentQ.questionText.textDirection
    );
    await editModal.then(async (modifiedCardText) => {
      if (this.reviewSequencer === null) return;
      await this.reviewSequencer.updateCurrentQuestionText(modifiedCardText);
      this.uiManager.setUIState(3 /* CardBack */);
    }).catch((reason) => console.log(reason));
  }
  async _jumpToCurrentCard() {
    var _a2;
    if (this.reviewSequencer === null) return;
    const currentQuestion = this.reviewSequencer.currentQuestion;
    if (!currentQuestion) return;
    if (!this.settings.openViewInNewTab && !(import_obsidian16.Platform.isMobile || EmulatedPlatform().isMobile) || !this.settings.openViewInNewTabMobile && (import_obsidian16.Platform.isMobile || EmulatedPlatform().isMobile)) {
      new import_obsidian16.Notice("Note was opened in new tab in the background");
    }
    const file = currentQuestion.note.file.tfile;
    const blockId = currentQuestion.questionText.obsidianBlockId;
    const line = Math.max(0, (_a2 = currentQuestion.lineNo) != null ? _a2 : 0);
    if (blockId) {
      await this.app.workspace.openLinkText(`${file.path}#${blockId}`, file.path, false);
      return;
    }
    const existingLeaf = this.app.workspace.getLeavesOfType("markdown").find((leaf2) => {
      var _a3;
      const view = leaf2.view;
      return ((_a3 = view.file) == null ? void 0 : _a3.path) === file.path;
    });
    if (existingLeaf) {
      await existingLeaf.openFile(file, { eState: { line } });
      this.app.workspace.setActiveLeaf(existingLeaf);
      const markdownView2 = existingLeaf.view;
      if (markdownView2 == null ? void 0 : markdownView2.editor) {
        markdownView2.editor.setCursor({ line, ch: 0 });
        markdownView2.editor.scrollIntoView({ from: { line, ch: 0 }, to: { line, ch: 0 } });
      }
      return;
    }
    const leaf = this.app.workspace.getLeaf("tab");
    await leaf.openFile(file, { eState: { line } });
    const markdownView = leaf.view;
    if (markdownView == null ? void 0 : markdownView.editor) {
      markdownView.editor.setCursor({ line, ch: 0 });
      markdownView.editor.scrollIntoView({ from: { line, ch: 0 }, to: { line, ch: 0 } });
    }
  }
  async _skipCurrentCard() {
    if (this.reviewSequencer === null) return;
    this.reviewSequencer.skipCurrentCard();
    await this._showNextCard();
  }
  _displayCurrentCardInfoNotice() {
    if (this.sessionData === null) return;
    new CardInfoNotice(
      this.sessionData.cardData.currentCard.scheduleInfo,
      this.sessionData.currentNote.file.path
    );
  }
  async _processReview(response) {
    if (this.reviewSequencer === null) return;
    const timeNow = (0, import_moment4.now)();
    if (timeNow - this.lastPressedOnProcessReview < this.dataManager.data.settings.reviewButtonDelay) {
      return;
    }
    this.lastPressedOnProcessReview = timeNow;
    await this.reviewSequencer.processReview(response);
    await this._showNextCard();
  }
  // MARK: Deck button handlers
  async _startReviewOfDeck(deck) {
    if (this.reviewSequencer === null) return;
    this.reviewSequencer.setCurrentDeck(deck.getTopicPath());
    if (this.reviewSequencer.hasCurrentCard) {
      await this._reviewDeck(deck);
    } else {
      await this._showDecksList();
    }
  }
  async _changeReviewMode(reviewMode) {
    this.reviewQueueLoader.setReviewMode(reviewMode);
    this.reviewMode = reviewMode;
    this.reviewSequencer = await this.reviewQueueLoader.loadReviewQueue();
    this.deckContainer.closeList();
    await this._showDecksList();
  }
  // MARK: Utils
  _determineButtonSchedule(reviewResponse) {
    if (this.sessionData === null) return null;
    if (this.reviewSequencer === null) return null;
    return this.reviewSequencer.determineCardSchedule(
      reviewResponse,
      this.sessionData.cardData.currentCard
    );
  }
  _clearPendingResumeTimeout() {
    if (this.pendingResumeTimeout !== null) {
      window.clearTimeout(this.pendingResumeTimeout);
      this.pendingResumeTimeout = null;
    }
  }
};

// src/ui/obsidian-ui-components/item-views/sr-tab-view.tsx
var SRTabView = class extends import_obsidian17.ItemView {
  constructor(leaf, plugin, settings, reviewQueueLoader) {
    super(leaf);
    this.reviewQueueLoader = null;
    this.contentManager = null;
    this.plugin = null;
    this.viewContainerEl = null;
    this.viewContentEl = null;
    this.settings = null;
    if (!plugin.isDataManagerLoaded()) {
      this.leaf.detach();
      return;
    }
    this.plugin = plugin;
    this.navigation = false;
    this.settings = settings;
    this.reviewQueueLoader = reviewQueueLoader;
    const viewContent = this.containerEl.getElementsByClassName("view-content");
    if (viewContent.length === 0) return;
    this.viewContainerEl = viewContent[0];
    this.viewContainerEl.addClass("sr-tab-view");
    this.viewContainerEl.addClass("sr-view");
    this.viewContentEl = this.viewContainerEl.createDiv("sr-tab-view-content");
    const isMobile = import_obsidian17.Platform.isMobile || EmulatedPlatform().isMobile;
    const heightPercent = isMobile ? this.settings.flashcardHeightPercentageMobile : this.settings.flashcardHeightPercentage;
    const widthPercent = isMobile ? this.settings.flashcardWidthPercentageMobile : this.settings.flashcardWidthPercentage;
    this.setSize(widthPercent, heightPercent);
    if (heightPercent < 100 || widthPercent < 100) {
      this.viewContentEl.addClass("sr-center-view");
    }
  }
  /**
   * Returns the view type identifier for the SRTabView.
   *
   * @returns {string} The view type identifier.
   */
  getViewType() {
    return SR_TAB_VIEW;
  }
  /**
   * Retrieves the icon identifier for the SRTabView.
   *
   * @returns {string} The tab icon identifier.
   */
  getIcon() {
    return "SpacedRepIcon";
  }
  /**
   * Returns the display text for the SRTabView.
   *
   * @returns {string} The display text for the SRTabView.
   */
  getDisplayText() {
    return "Spaced Repetition";
  }
  /**
   * Initializes the SRTabView when opened by loading the review sequencer data
   * and setting up the deck and flashcard views if they are not already initialized.
   */
  async onOpen() {
    if (this.viewContainerEl === null || this.viewContentEl === null || this.reviewQueueLoader === null)
      return;
    if (activeDocument.body.classList.contains("is-mobile")) {
      const mobileNavbar = activeDocument.getElementsByClassName("mobile-navbar")[0];
      if (mobileNavbar) {
        mobileNavbar.setCssProps({ position: "relative" });
      }
    }
    if (activeDocument.body.classList.contains("is-phone") && activeDocument.body.classList.contains("is-floating-nav")) {
      activeDocument.body.style.setProperty(
        "--view-bottom-fade-mask",
        "linear-gradient(to top, rgba(0, 0, 0, 0.5) 0%, #000000 calc(16px - 0px))"
      );
    }
    if (this.settings === null || this.plugin === null) {
      this.leaf.detach();
      return;
    }
    this.contentManager = new ContentManager(
      this.app,
      this.plugin,
      this.reviewQueueLoader,
      this.settings,
      this.viewContentEl
    );
    if (this.plugin.uiManager === null) throw new Error("UI manager not initialized!!!");
    this.plugin.uiManager.setContentManager(this.contentManager);
    await this.contentManager.open();
  }
  /**
   * Closes the SRTabView by shutting down any active deck or flashcard views.
   * Ensures that resources associated with these views are properly released.
   */
  // eslint-disable-next-line @typescript-eslint/require-await
  async onClose() {
    if (activeDocument.body.classList.contains("is-mobile")) {
      const mobileNavbar = activeDocument.getElementsByClassName("mobile-navbar")[0];
      if (mobileNavbar) {
        mobileNavbar.setCssProps({ position: "unset" });
      }
    }
    if (activeDocument.body.classList.contains("is-phone") && activeDocument.body.classList.contains("is-floating-nav")) {
      activeDocument.body.style.setProperty(
        "--view-bottom-fade-mask",
        "linear-gradient(to top, rgba(0, 0, 0, 0.5) 0%, #000000 calc(34px - 0px + 12px))"
      );
    }
    if (this.contentManager) this.contentManager.close();
  }
  setSize(widthPercent, heightPercent) {
    if (!this.viewContentEl) return;
    this.viewContentEl.setCssProps({
      width: widthPercent + "%",
      "max-width": widthPercent + "%",
      height: heightPercent + "%",
      "max-height": heightPercent + "%"
    });
  }
};

// src/ui/obsidian-ui-components/modals/sr-modal-view.tsx
var import_obsidian18 = require("obsidian");
var SRModalView = class extends import_obsidian18.Modal {
  constructor(app, plugin, settingsManager, reviewQueueLoader) {
    super(app);
    this.resizeObserver = null;
    this.plugin = plugin;
    this.settingsManager = settingsManager;
    if (import_obsidian18.Platform.isMobile || EmulatedPlatform().isMobile) {
      this.setModalSize(
        this.settingsManager.settings.flashcardHeightPercentageMobile,
        this.settingsManager.settings.flashcardWidthPercentageMobile
      );
    } else {
      this.setModalSize(
        this.settingsManager.settings.flashcardHeightPercentage,
        this.settingsManager.settings.flashcardWidthPercentage
      );
      this.resizeObserver = new ResizeObserver((entries) => {
        void this.onResize(entries);
      });
      this.resizeObserver.observe(this.modalEl);
    }
    this.modalEl.setAttribute("id", "sr-modal-view");
    this.modalEl.addClass("sr-view");
    this.contentEl.addClass("sr-modal-content");
    this.contentManager = new ContentManager(
      app,
      plugin,
      reviewQueueLoader,
      this.settingsManager.settings,
      this.contentEl,
      () => {
        this.close();
      }
    );
    this.plugin.uiManager.setContentManager(this.contentManager);
  }
  onOpen() {
    void this.contentManager.open();
  }
  onClose() {
    this.contentManager.close();
  }
  async onResize(entries) {
    const modalEl = entries[0].target;
    const parent = modalEl.parentElement;
    if (parent === null) return;
    const elementHeight = modalEl.offsetHeight;
    const parentHeight = parent.offsetHeight;
    const heightPercent = elementHeight / parentHeight * 100;
    const elementWidth = modalEl.offsetWidth;
    const parentWidth = parent.offsetWidth;
    const widthPercent = elementWidth / parentWidth * 100;
    this.setRoundedModalCorners(!(heightPercent >= 100 || widthPercent >= 100));
    await this.saveSizeToSettings(
      heightPercent,
      widthPercent,
      import_obsidian18.Platform.isMobile || EmulatedPlatform().isMobile
    );
  }
  setRoundedModalCorners(rounded) {
    this.modalEl.setCssProps({ "border-Radius": rounded ? "var(--modal-radius)" : "0" });
  }
  setModalSize(heightPercent, widthPercent) {
    this.modalEl.setCssProps({ height: heightPercent + "%" });
    this.modalEl.setCssProps({ width: widthPercent + "%" });
    this.setRoundedModalCorners(
      !(parseInt(this.modalEl.getCssPropertyValue("height").split("%")[0]) >= 100 || parseInt(this.modalEl.getCssPropertyValue("width").split("%")[0]) >= 100)
    );
  }
  async saveSizeToSettings(heightPercent, widthPercent, isMobile) {
    if (isNaN(heightPercent) || isNaN(widthPercent)) return;
    if (isMobile) {
      this.settingsManager.settings.flashcardHeightPercentageMobile = heightPercent;
      this.settingsManager.settings.flashcardWidthPercentageMobile = widthPercent;
    } else {
      this.settingsManager.settings.flashcardHeightPercentage = heightPercent;
      this.settingsManager.settings.flashcardWidthPercentage = widthPercent;
    }
    await this.plugin.dataManager.savePluginData();
  }
};

// src/ui/obsidian-ui-components/settings-tab.tsx
var import_obsidian28 = require("obsidian");

// src/ui/obsidian-ui-components/content-container/settings-page/data-page.tsx
var import_obsidian20 = require("obsidian");

// node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
var balanced = (a2, b2, str) => {
  const ma = a2 instanceof RegExp ? maybeMatch(a2, str) : a2;
  const mb = b2 instanceof RegExp ? maybeMatch(b2, str) : b2;
  const r2 = ma !== null && mb != null && range(ma, mb, str);
  return r2 && {
    start: r2[0],
    end: r2[1],
    pre: str.slice(0, r2[0]),
    body: str.slice(r2[0] + ma.length, r2[1]),
    post: str.slice(r2[1] + mb.length)
  };
};
var maybeMatch = (reg, str) => {
  const m2 = str.match(reg);
  return m2 ? m2[0] : null;
};
var range = (a2, b2, str) => {
  let begs, beg, left, right = void 0, result;
  let ai = str.indexOf(a2);
  let bi = str.indexOf(b2, ai + 1);
  let i2 = ai;
  if (ai >= 0 && bi > 0) {
    if (a2 === b2) {
      return [ai, bi];
    }
    begs = [];
    left = str.length;
    while (i2 >= 0 && !result) {
      if (i2 === ai) {
        begs.push(i2);
        ai = str.indexOf(a2, i2 + 1);
      } else if (begs.length === 1) {
        const r2 = begs.pop();
        if (r2 !== void 0)
          result = [r2, bi];
      } else {
        beg = begs.pop();
        if (beg !== void 0 && beg < left) {
          left = beg;
          right = bi;
        }
        bi = str.indexOf(b2, i2 + 1);
      }
      i2 = ai < bi && ai >= 0 ? ai : bi;
    }
    if (begs.length && right !== void 0) {
      result = [left, right];
    }
  }
  return result;
};

// node_modules/.pnpm/brace-expansion@5.0.6/node_modules/brace-expansion/dist/esm/index.js
var escSlash = "\0SLASH" + Math.random() + "\0";
var escOpen = "\0OPEN" + Math.random() + "\0";
var escClose = "\0CLOSE" + Math.random() + "\0";
var escComma = "\0COMMA" + Math.random() + "\0";
var escPeriod = "\0PERIOD" + Math.random() + "\0";
var escSlashPattern = new RegExp(escSlash, "g");
var escOpenPattern = new RegExp(escOpen, "g");
var escClosePattern = new RegExp(escClose, "g");
var escCommaPattern = new RegExp(escComma, "g");
var escPeriodPattern = new RegExp(escPeriod, "g");
var slashPattern = /\\\\/g;
var openPattern = /\\{/g;
var closePattern = /\\}/g;
var commaPattern = /\\,/g;
var periodPattern = /\\\./g;
var EXPANSION_MAX = 1e5;
function numeric(str) {
  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
}
function escapeBraces(str) {
  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
}
function unescapeBraces(str) {
  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
}
function parseCommaParts(str) {
  if (!str) {
    return [""];
  }
  const parts = [];
  const m2 = balanced("{", "}", str);
  if (!m2) {
    return str.split(",");
  }
  const { pre, body, post } = m2;
  const p2 = pre.split(",");
  p2[p2.length - 1] += "{" + body + "}";
  const postParts = parseCommaParts(post);
  if (post.length) {
    ;
    p2[p2.length - 1] += postParts.shift();
    p2.push.apply(p2, postParts);
  }
  parts.push.apply(parts, p2);
  return parts;
}
function expand(str, options = {}) {
  if (!str) {
    return [];
  }
  const { max = EXPANSION_MAX } = options;
  if (str.slice(0, 2) === "{}") {
    str = "\\{\\}" + str.slice(2);
  }
  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
}
function embrace(str) {
  return "{" + str + "}";
}
function isPadded(el) {
  return /^-?0\d/.test(el);
}
function lte(i2, y2) {
  return i2 <= y2;
}
function gte(i2, y2) {
  return i2 >= y2;
}
function expand_(str, max, isTop) {
  const expansions = [];
  const m2 = balanced("{", "}", str);
  if (!m2)
    return [str];
  const pre = m2.pre;
  const post = m2.post.length ? expand_(m2.post, max, false) : [""];
  if (/\$$/.test(m2.pre)) {
    for (let k = 0; k < post.length && k < max; k++) {
      const expansion = pre + "{" + m2.body + "}" + post[k];
      expansions.push(expansion);
    }
  } else {
    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m2.body);
    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m2.body);
    const isSequence = isNumericSequence || isAlphaSequence;
    const isOptions = m2.body.indexOf(",") >= 0;
    if (!isSequence && !isOptions) {
      if (m2.post.match(/,(?!,).*\}/)) {
        str = m2.pre + "{" + m2.body + escClose + m2.post;
        return expand_(str, max, true);
      }
      return [str];
    }
    let n2;
    if (isSequence) {
      n2 = m2.body.split(/\.\./);
    } else {
      n2 = parseCommaParts(m2.body);
      if (n2.length === 1 && n2[0] !== void 0) {
        n2 = expand_(n2[0], max, false).map(embrace);
        if (n2.length === 1) {
          return post.map((p2) => m2.pre + n2[0] + p2);
        }
      }
    }
    let N2;
    if (isSequence && n2[0] !== void 0 && n2[1] !== void 0) {
      const x2 = numeric(n2[0]);
      const y2 = numeric(n2[1]);
      const width = Math.max(n2[0].length, n2[1].length);
      let incr = n2.length === 3 && n2[2] !== void 0 ? Math.max(Math.abs(numeric(n2[2])), 1) : 1;
      let test = lte;
      const reverse = y2 < x2;
      if (reverse) {
        incr *= -1;
        test = gte;
      }
      const pad = n2.some(isPadded);
      N2 = [];
      for (let i2 = x2; test(i2, y2) && N2.length < max; i2 += incr) {
        let c2;
        if (isAlphaSequence) {
          c2 = String.fromCharCode(i2);
          if (c2 === "\\") {
            c2 = "";
          }
        } else {
          c2 = String(i2);
          if (pad) {
            const need = width - c2.length;
            if (need > 0) {
              const z2 = new Array(need + 1).join("0");
              if (i2 < 0) {
                c2 = "-" + z2 + c2.slice(1);
              } else {
                c2 = z2 + c2;
              }
            }
          }
        }
        N2.push(c2);
      }
    } else {
      N2 = [];
      for (let j2 = 0; j2 < n2.length; j2++) {
        N2.push.apply(N2, expand_(n2[j2], max, false));
      }
    }
    for (let j2 = 0; j2 < N2.length; j2++) {
      for (let k = 0; k < post.length && expansions.length < max; k++) {
        const expansion = pre + N2[j2] + post[k];
        if (!isTop || isSequence || expansion) {
          expansions.push(expansion);
        }
      }
    }
  }
  return expansions;
}

// node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/assert-valid-pattern.js
var MAX_PATTERN_LENGTH = 1024 * 64;
var assertValidPattern = (pattern) => {
  if (typeof pattern !== "string") {
    throw new TypeError("invalid pattern");
  }
  if (pattern.length > MAX_PATTERN_LENGTH) {
    throw new TypeError("pattern is too long");
  }
};

// node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/brace-expressions.js
var posixClasses = {
  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
  "[:ascii:]": ["\\x00-\\x7f", false],
  "[:blank:]": ["\\p{Zs}\\t", true],
  "[:cntrl:]": ["\\p{Cc}", true],
  "[:digit:]": ["\\p{Nd}", true],
  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
  "[:lower:]": ["\\p{Ll}", true],
  "[:print:]": ["\\p{C}", true],
  "[:punct:]": ["\\p{P}", true],
  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
  "[:upper:]": ["\\p{Lu}", true],
  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
  "[:xdigit:]": ["A-Fa-f0-9", false]
};
var braceEscape = (s2) => s2.replace(/[[\]\\-]/g, "\\$&");
var regexpEscape = (s2) => s2.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
var rangesToString = (ranges) => ranges.join("");
var parseClass = (glob, position) => {
  const pos = position;
  if (glob.charAt(pos) !== "[") {
    throw new Error("not in a brace expression");
  }
  const ranges = [];
  const negs = [];
  let i2 = pos + 1;
  let sawStart = false;
  let uflag = false;
  let escaping = false;
  let negate = false;
  let endPos = pos;
  let rangeStart = "";
  WHILE: while (i2 < glob.length) {
    const c2 = glob.charAt(i2);
    if ((c2 === "!" || c2 === "^") && i2 === pos + 1) {
      negate = true;
      i2++;
      continue;
    }
    if (c2 === "]" && sawStart && !escaping) {
      endPos = i2 + 1;
      break;
    }
    sawStart = true;
    if (c2 === "\\") {
      if (!escaping) {
        escaping = true;
        i2++;
        continue;
      }
    }
    if (c2 === "[" && !escaping) {
      for (const [cls, [unip, u2, neg]] of Object.entries(posixClasses)) {
        if (glob.startsWith(cls, i2)) {
          if (rangeStart) {
            return ["$.", false, glob.length - pos, true];
          }
          i2 += cls.length;
          if (neg)
            negs.push(unip);
          else
            ranges.push(unip);
          uflag = uflag || u2;
          continue WHILE;
        }
      }
    }
    escaping = false;
    if (rangeStart) {
      if (c2 > rangeStart) {
        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c2));
      } else if (c2 === rangeStart) {
        ranges.push(braceEscape(c2));
      }
      rangeStart = "";
      i2++;
      continue;
    }
    if (glob.startsWith("-]", i2 + 1)) {
      ranges.push(braceEscape(c2 + "-"));
      i2 += 2;
      continue;
    }
    if (glob.startsWith("-", i2 + 1)) {
      rangeStart = c2;
      i2 += 2;
      continue;
    }
    ranges.push(braceEscape(c2));
    i2++;
  }
  if (endPos < i2) {
    return ["", false, 0, false];
  }
  if (!ranges.length && !negs.length) {
    return ["$.", false, glob.length - pos, true];
  }
  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
    const r2 = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
    return [regexpEscape(r2), false, endPos - pos, false];
  }
  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
  return [comb, uflag, endPos - pos, true];
};

// node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/unescape.js
var unescape = (s2, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
  if (magicalBraces) {
    return windowsPathsNoEscape ? s2.replace(/\[([^/\\])\]/g, "$1") : s2.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1");
  }
  return windowsPathsNoEscape ? s2.replace(/\[([^/\\{}])\]/g, "$1") : s2.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
};

// node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/ast.js
var _a;
var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
var isExtglobType = (c2) => types.has(c2);
var isExtglobAST = (c2) => isExtglobType(c2.type);
var adoptionMap = /* @__PURE__ */ new Map([
  ["!", ["@"]],
  ["?", ["?", "@"]],
  ["@", ["@"]],
  ["*", ["*", "+", "?", "@"]],
  ["+", ["+", "@"]]
]);
var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
  ["!", ["?"]],
  ["@", ["?"]],
  ["+", ["?", "*"]]
]);
var adoptionAnyMap = /* @__PURE__ */ new Map([
  ["!", ["?", "@"]],
  ["?", ["?", "@"]],
  ["@", ["?", "@"]],
  ["*", ["*", "+", "?", "@"]],
  ["+", ["+", "@", "?", "*"]]
]);
var usurpMap = /* @__PURE__ */ new Map([
  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
  [
    "?",
    /* @__PURE__ */ new Map([
      ["*", "*"],
      ["+", "*"]
    ])
  ],
  [
    "@",
    /* @__PURE__ */ new Map([
      ["!", "!"],
      ["?", "?"],
      ["@", "@"],
      ["*", "*"],
      ["+", "+"]
    ])
  ],
  [
    "+",
    /* @__PURE__ */ new Map([
      ["?", "*"],
      ["*", "*"]
    ])
  ]
]);
var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
var startNoDot = "(?!\\.)";
var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
var justDots = /* @__PURE__ */ new Set(["..", "."]);
var reSpecials = new Set("().*{}+?[]^$\\!");
var regExpEscape = (s2) => s2.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
var qmark = "[^/]";
var star = qmark + "*?";
var starNoEmpty = qmark + "+?";
var ID = 0;
var _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, canAdoptWithSpace_fn, canAdopt_fn, canAdoptType_fn, adoptWithSpace_fn, adopt_fn, canUsurpType_fn, canUsurp_fn, usurp_fn, flatten_fn, partsToRegExp_fn, parseGlob_fn;
var AST = class {
  constructor(type, parent, options = {}) {
    __privateAdd(this, _AST_instances);
    __publicField(this, "type");
    __privateAdd(this, _root);
    __privateAdd(this, _hasMagic);
    __privateAdd(this, _uflag, false);
    __privateAdd(this, _parts, []);
    __privateAdd(this, _parent);
    __privateAdd(this, _parentIndex);
    __privateAdd(this, _negs);
    __privateAdd(this, _filledNegs, false);
    __privateAdd(this, _options);
    __privateAdd(this, _toString);
    // set to true if it's an extglob with no children
    // (which really means one child of '')
    __privateAdd(this, _emptyExt, false);
    __publicField(this, "id", ++ID);
    this.type = type;
    if (type)
      __privateSet(this, _hasMagic, true);
    __privateSet(this, _parent, parent);
    __privateSet(this, _root, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _root) : this);
    __privateSet(this, _options, __privateGet(this, _root) === this ? options : __privateGet(__privateGet(this, _root), _options));
    __privateSet(this, _negs, __privateGet(this, _root) === this ? [] : __privateGet(__privateGet(this, _root), _negs));
    if (type === "!" && !__privateGet(__privateGet(this, _root), _filledNegs))
      __privateGet(this, _negs).push(this);
    __privateSet(this, _parentIndex, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0);
  }
  get depth() {
    var _a2, _b;
    return ((_b = (_a2 = __privateGet(this, _parent)) == null ? void 0 : _a2.depth) != null ? _b : -1) + 1;
  }
  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
    var _a2;
    return {
      "@@type": "AST",
      id: this.id,
      type: this.type,
      root: __privateGet(this, _root).id,
      parent: (_a2 = __privateGet(this, _parent)) == null ? void 0 : _a2.id,
      depth: this.depth,
      partsLength: __privateGet(this, _parts).length,
      parts: __privateGet(this, _parts)
    };
  }
  get hasMagic() {
    if (__privateGet(this, _hasMagic) !== void 0)
      return __privateGet(this, _hasMagic);
    for (const p2 of __privateGet(this, _parts)) {
      if (typeof p2 === "string")
        continue;
      if (p2.type || p2.hasMagic)
        return __privateSet(this, _hasMagic, true);
    }
    return __privateGet(this, _hasMagic);
  }
  // reconstructs the pattern
  toString() {
    return __privateGet(this, _toString) !== void 0 ? __privateGet(this, _toString) : !this.type ? __privateSet(this, _toString, __privateGet(this, _parts).map((p2) => String(p2)).join("")) : __privateSet(this, _toString, this.type + "(" + __privateGet(this, _parts).map((p2) => String(p2)).join("|") + ")");
  }
  push(...parts) {
    for (const p2 of parts) {
      if (p2 === "")
        continue;
      if (typeof p2 !== "string" && !(p2 instanceof _a && __privateGet(p2, _parent) === this)) {
        throw new Error("invalid part: " + p2);
      }
      __privateGet(this, _parts).push(p2);
    }
  }
  toJSON() {
    var _a2;
    const ret = this.type === null ? __privateGet(this, _parts).slice().map((p2) => typeof p2 === "string" ? p2 : p2.toJSON()) : [this.type, ...__privateGet(this, _parts).map((p2) => p2.toJSON())];
    if (this.isStart() && !this.type)
      ret.unshift([]);
    if (this.isEnd() && (this === __privateGet(this, _root) || __privateGet(__privateGet(this, _root), _filledNegs) && ((_a2 = __privateGet(this, _parent)) == null ? void 0 : _a2.type) === "!")) {
      ret.push({});
    }
    return ret;
  }
  isStart() {
    var _a2;
    if (__privateGet(this, _root) === this)
      return true;
    if (!((_a2 = __privateGet(this, _parent)) == null ? void 0 : _a2.isStart()))
      return false;
    if (__privateGet(this, _parentIndex) === 0)
      return true;
    const p2 = __privateGet(this, _parent);
    for (let i2 = 0; i2 < __privateGet(this, _parentIndex); i2++) {
      const pp = __privateGet(p2, _parts)[i2];
      if (!(pp instanceof _a && pp.type === "!")) {
        return false;
      }
    }
    return true;
  }
  isEnd() {
    var _a2, _b, _c;
    if (__privateGet(this, _root) === this)
      return true;
    if (((_a2 = __privateGet(this, _parent)) == null ? void 0 : _a2.type) === "!")
      return true;
    if (!((_b = __privateGet(this, _parent)) == null ? void 0 : _b.isEnd()))
      return false;
    if (!this.type)
      return (_c = __privateGet(this, _parent)) == null ? void 0 : _c.isEnd();
    const pl2 = __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0;
    return __privateGet(this, _parentIndex) === pl2 - 1;
  }
  copyIn(part) {
    if (typeof part === "string")
      this.push(part);
    else
      this.push(part.clone(this));
  }
  clone(parent) {
    const c2 = new _a(this.type, parent);
    for (const p2 of __privateGet(this, _parts)) {
      c2.copyIn(p2);
    }
    return c2;
  }
  static fromGlob(pattern, options = {}) {
    var _a2;
    const ast = new _a(null, void 0, options);
    __privateMethod(_a2 = _a, _AST_static, parseAST_fn).call(_a2, pattern, ast, 0, options, 0);
    return ast;
  }
  // returns the regular expression if there's magic, or the unescaped
  // string if not.
  toMMPattern() {
    if (this !== __privateGet(this, _root))
      return __privateGet(this, _root).toMMPattern();
    const glob = this.toString();
    const [re, body, hasMagic, uflag] = this.toRegExpSource();
    const anyMagic = hasMagic || __privateGet(this, _hasMagic) || __privateGet(this, _options).nocase && !__privateGet(this, _options).nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
    if (!anyMagic) {
      return body;
    }
    const flags = (__privateGet(this, _options).nocase ? "i" : "") + (uflag ? "u" : "");
    return Object.assign(new RegExp(`^${re}$`, flags), {
      _src: re,
      _glob: glob
    });
  }
  get options() {
    return __privateGet(this, _options);
  }
  // returns the string match, the regexp source, whether there's magic
  // in the regexp (so a regular expression is required) and whether or
  // not the uflag is needed for the regular expression (for posix classes)
  // TODO: instead of injecting the start/end at this point, just return
  // the BODY of the regexp, along with the start/end portions suitable
  // for binding the start/end in either a joined full-path makeRe context
  // (where we bind to (^|/), or a standalone matchPart context (where
  // we bind to ^, and not /).  Otherwise slashes get duped!
  //
  // In part-matching mode, the start is:
  // - if not isStart: nothing
  // - if traversal possible, but not allowed: ^(?!\.\.?$)
  // - if dots allowed or not possible: ^
  // - if dots possible and not allowed: ^(?!\.)
  // end is:
  // - if not isEnd(): nothing
  // - else: $
  //
  // In full-path matching mode, we put the slash at the START of the
  // pattern, so start is:
  // - if first pattern: same as part-matching mode
  // - if not isStart(): nothing
  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
  // - if dots allowed or not possible: /
  // - if dots possible and not allowed: /(?!\.)
  // end is:
  // - if last pattern, same as part-matching mode
  // - else nothing
  //
  // Always put the (?:$|/) on negated tails, though, because that has to be
  // there to bind the end of the negated pattern portion, and it's easier to
  // just stick it in now rather than try to inject it later in the middle of
  // the pattern.
  //
  // We can just always return the same end, and leave it up to the caller
  // to know whether it's going to be used joined or in parts.
  // And, if the start is adjusted slightly, can do the same there:
  // - if not isStart: nothing
  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
  // - if dots allowed or not possible: (?:/|^)
  // - if dots possible and not allowed: (?:/|^)(?!\.)
  //
  // But it's better to have a simpler binding without a conditional, for
  // performance, so probably better to return both start options.
  //
  // Then the caller just ignores the end if it's not the first pattern,
  // and the start always gets applied.
  //
  // But that's always going to be $ if it's the ending pattern, or nothing,
  // so the caller can just attach $ at the end of the pattern when building.
  //
  // So the todo is:
  // - better detect what kind of start is needed
  // - return both flavors of starting pattern
  // - attach $ at the end of the pattern when creating the actual RegExp
  //
  // Ah, but wait, no, that all only applies to the root when the first pattern
  // is not an extglob. If the first pattern IS an extglob, then we need all
  // that dot prevention biz to live in the extglob portions, because eg
  // +(*|.x*) can match .xy but not .yx.
  //
  // So, return the two flavors if it's #root and the first child is not an
  // AST, otherwise leave it to the child AST to handle it, and there,
  // use the (?:^|/) style of start binding.
  //
  // Even simplified further:
  // - Since the start for a join is eg /(?!\.) and the start for a part
  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
  // or start or whatever) and prepend ^ or / at the Regexp construction.
  toRegExpSource(allowDot) {
    var _a2;
    const dot = allowDot != null ? allowDot : !!__privateGet(this, _options).dot;
    if (__privateGet(this, _root) === this) {
      __privateMethod(this, _AST_instances, flatten_fn).call(this);
      __privateMethod(this, _AST_instances, fillNegs_fn).call(this);
    }
    if (!isExtglobAST(this)) {
      const noEmpty = this.isStart() && this.isEnd() && !__privateGet(this, _parts).some((s2) => typeof s2 !== "string");
      const src = __privateGet(this, _parts).map((p2) => {
        var _a3;
        const [re, _2, hasMagic, uflag] = typeof p2 === "string" ? __privateMethod(_a3 = _a, _AST_static, parseGlob_fn).call(_a3, p2, __privateGet(this, _hasMagic), noEmpty) : p2.toRegExpSource(allowDot);
        __privateSet(this, _hasMagic, __privateGet(this, _hasMagic) || hasMagic);
        __privateSet(this, _uflag, __privateGet(this, _uflag) || uflag);
        return re;
      }).join("");
      let start2 = "";
      if (this.isStart()) {
        if (typeof __privateGet(this, _parts)[0] === "string") {
          const dotTravAllowed = __privateGet(this, _parts).length === 1 && justDots.has(__privateGet(this, _parts)[0]);
          if (!dotTravAllowed) {
            const aps = addPatternStart;
            const needNoTrav = (
              // dots are allowed, and the pattern starts with [ or .
              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
            );
            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
          }
        }
      }
      let end = "";
      if (this.isEnd() && __privateGet(__privateGet(this, _root), _filledNegs) && ((_a2 = __privateGet(this, _parent)) == null ? void 0 : _a2.type) === "!") {
        end = "(?:$|\\/)";
      }
      const final2 = start2 + src + end;
      return [
        final2,
        unescape(src),
        __privateSet(this, _hasMagic, !!__privateGet(this, _hasMagic)),
        __privateGet(this, _uflag)
      ];
    }
    const repeated = this.type === "*" || this.type === "+";
    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
    let body = __privateMethod(this, _AST_instances, partsToRegExp_fn).call(this, dot);
    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
      const s2 = this.toString();
      const me = this;
      __privateSet(me, _parts, [s2]);
      me.type = null;
      __privateSet(me, _hasMagic, void 0);
      return [s2, unescape(this.toString()), false, false];
    }
    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : __privateMethod(this, _AST_instances, partsToRegExp_fn).call(this, true);
    if (bodyDotAllowed === body) {
      bodyDotAllowed = "";
    }
    if (bodyDotAllowed) {
      body = `(?:${body})(?:${bodyDotAllowed})*?`;
    }
    let final = "";
    if (this.type === "!" && __privateGet(this, _emptyExt)) {
      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
    } else {
      const close = this.type === "!" ? (
        // !() must match something,but !(x) can match ''
        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
      final = start + body + close;
    }
    return [
      final,
      unescape(body),
      __privateSet(this, _hasMagic, !!__privateGet(this, _hasMagic)),
      __privateGet(this, _uflag)
    ];
  }
};
_root = new WeakMap();
_hasMagic = new WeakMap();
_uflag = new WeakMap();
_parts = new WeakMap();
_parent = new WeakMap();
_parentIndex = new WeakMap();
_negs = new WeakMap();
_filledNegs = new WeakMap();
_options = new WeakMap();
_toString = new WeakMap();
_emptyExt = new WeakMap();
_AST_instances = new WeakSet();
fillNegs_fn = function() {
  if (this !== __privateGet(this, _root))
    throw new Error("should only call on root");
  if (__privateGet(this, _filledNegs))
    return this;
  this.toString();
  __privateSet(this, _filledNegs, true);
  let n2;
  while (n2 = __privateGet(this, _negs).pop()) {
    if (n2.type !== "!")
      continue;
    let p2 = n2;
    let pp = __privateGet(p2, _parent);
    while (pp) {
      for (let i2 = __privateGet(p2, _parentIndex) + 1; !pp.type && i2 < __privateGet(pp, _parts).length; i2++) {
        for (const part of __privateGet(n2, _parts)) {
          if (typeof part === "string") {
            throw new Error("string part in extglob AST??");
          }
          part.copyIn(__privateGet(pp, _parts)[i2]);
        }
      }
      p2 = pp;
      pp = __privateGet(p2, _parent);
    }
  }
  return this;
};
_AST_static = new WeakSet();
parseAST_fn = function(str, ast, pos, opt, extDepth) {
  var _a2, _b, _c, _d, _e;
  const maxDepth = (_a2 = opt.maxExtglobRecursion) != null ? _a2 : 2;
  let escaping = false;
  let inBrace = false;
  let braceStart = -1;
  let braceNeg = false;
  if (ast.type === null) {
    let i3 = pos;
    let acc2 = "";
    while (i3 < str.length) {
      const c2 = str.charAt(i3++);
      if (escaping || c2 === "\\") {
        escaping = !escaping;
        acc2 += c2;
        continue;
      }
      if (inBrace) {
        if (i3 === braceStart + 1) {
          if (c2 === "^" || c2 === "!") {
            braceNeg = true;
          }
        } else if (c2 === "]" && !(i3 === braceStart + 2 && braceNeg)) {
          inBrace = false;
        }
        acc2 += c2;
        continue;
      } else if (c2 === "[") {
        inBrace = true;
        braceStart = i3;
        braceNeg = false;
        acc2 += c2;
        continue;
      }
      const doRecurse = !opt.noext && isExtglobType(c2) && str.charAt(i3) === "(" && extDepth <= maxDepth;
      if (doRecurse) {
        ast.push(acc2);
        acc2 = "";
        const ext2 = new _a(c2, ast);
        i3 = __privateMethod(_b = _a, _AST_static, parseAST_fn).call(_b, str, ext2, i3, opt, extDepth + 1);
        ast.push(ext2);
        continue;
      }
      acc2 += c2;
    }
    ast.push(acc2);
    return i3;
  }
  let i2 = pos + 1;
  let part = new _a(null, ast);
  const parts = [];
  let acc = "";
  while (i2 < str.length) {
    const c2 = str.charAt(i2++);
    if (escaping || c2 === "\\") {
      escaping = !escaping;
      acc += c2;
      continue;
    }
    if (inBrace) {
      if (i2 === braceStart + 1) {
        if (c2 === "^" || c2 === "!") {
          braceNeg = true;
        }
      } else if (c2 === "]" && !(i2 === braceStart + 2 && braceNeg)) {
        inBrace = false;
      }
      acc += c2;
      continue;
    } else if (c2 === "[") {
      inBrace = true;
      braceStart = i2;
      braceNeg = false;
      acc += c2;
      continue;
    }
    const doRecurse = !opt.noext && isExtglobType(c2) && str.charAt(i2) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
    (extDepth <= maxDepth || ast && __privateMethod(_c = ast, _AST_instances, canAdoptType_fn).call(_c, c2));
    if (doRecurse) {
      const depthAdd = ast && __privateMethod(_d = ast, _AST_instances, canAdoptType_fn).call(_d, c2) ? 0 : 1;
      part.push(acc);
      acc = "";
      const ext2 = new _a(c2, part);
      part.push(ext2);
      i2 = __privateMethod(_e = _a, _AST_static, parseAST_fn).call(_e, str, ext2, i2, opt, extDepth + depthAdd);
      continue;
    }
    if (c2 === "|") {
      part.push(acc);
      acc = "";
      parts.push(part);
      part = new _a(null, ast);
      continue;
    }
    if (c2 === ")") {
      if (acc === "" && __privateGet(ast, _parts).length === 0) {
        __privateSet(ast, _emptyExt, true);
      }
      part.push(acc);
      acc = "";
      ast.push(...parts, part);
      return i2;
    }
    acc += c2;
  }
  ast.type = null;
  __privateSet(ast, _hasMagic, void 0);
  __privateSet(ast, _parts, [str.substring(pos - 1)]);
  return i2;
};
canAdoptWithSpace_fn = function(child) {
  return __privateMethod(this, _AST_instances, canAdopt_fn).call(this, child, adoptionWithSpaceMap);
};
canAdopt_fn = function(child, map3 = adoptionMap) {
  if (!child || typeof child !== "object" || child.type !== null || __privateGet(child, _parts).length !== 1 || this.type === null) {
    return false;
  }
  const gc = __privateGet(child, _parts)[0];
  if (!gc || typeof gc !== "object" || gc.type === null) {
    return false;
  }
  return __privateMethod(this, _AST_instances, canAdoptType_fn).call(this, gc.type, map3);
};
canAdoptType_fn = function(c2, map3 = adoptionAnyMap) {
  var _a2;
  return !!((_a2 = map3.get(this.type)) == null ? void 0 : _a2.includes(c2));
};
adoptWithSpace_fn = function(child, index) {
  const gc = __privateGet(child, _parts)[0];
  const blank = new _a(null, gc, this.options);
  __privateGet(blank, _parts).push("");
  gc.push(blank);
  __privateMethod(this, _AST_instances, adopt_fn).call(this, child, index);
};
adopt_fn = function(child, index) {
  const gc = __privateGet(child, _parts)[0];
  __privateGet(this, _parts).splice(index, 1, ...__privateGet(gc, _parts));
  for (const p2 of __privateGet(gc, _parts)) {
    if (typeof p2 === "object")
      __privateSet(p2, _parent, this);
  }
  __privateSet(this, _toString, void 0);
};
canUsurpType_fn = function(c2) {
  const m2 = usurpMap.get(this.type);
  return !!(m2 == null ? void 0 : m2.has(c2));
};
canUsurp_fn = function(child) {
  if (!child || typeof child !== "object" || child.type !== null || __privateGet(child, _parts).length !== 1 || this.type === null || __privateGet(this, _parts).length !== 1) {
    return false;
  }
  const gc = __privateGet(child, _parts)[0];
  if (!gc || typeof gc !== "object" || gc.type === null) {
    return false;
  }
  return __privateMethod(this, _AST_instances, canUsurpType_fn).call(this, gc.type);
};
usurp_fn = function(child) {
  const m2 = usurpMap.get(this.type);
  const gc = __privateGet(child, _parts)[0];
  const nt2 = m2 == null ? void 0 : m2.get(gc.type);
  if (!nt2)
    return false;
  __privateSet(this, _parts, __privateGet(gc, _parts));
  for (const p2 of __privateGet(this, _parts)) {
    if (typeof p2 === "object") {
      __privateSet(p2, _parent, this);
    }
  }
  this.type = nt2;
  __privateSet(this, _toString, void 0);
  __privateSet(this, _emptyExt, false);
};
flatten_fn = function() {
  var _a2, _b;
  if (!isExtglobAST(this)) {
    for (const p2 of __privateGet(this, _parts)) {
      if (typeof p2 === "object") {
        __privateMethod(_a2 = p2, _AST_instances, flatten_fn).call(_a2);
      }
    }
  } else {
    let iterations = 0;
    let done = false;
    do {
      done = true;
      for (let i2 = 0; i2 < __privateGet(this, _parts).length; i2++) {
        const c2 = __privateGet(this, _parts)[i2];
        if (typeof c2 === "object") {
          __privateMethod(_b = c2, _AST_instances, flatten_fn).call(_b);
          if (__privateMethod(this, _AST_instances, canAdopt_fn).call(this, c2)) {
            done = false;
            __privateMethod(this, _AST_instances, adopt_fn).call(this, c2, i2);
          } else if (__privateMethod(this, _AST_instances, canAdoptWithSpace_fn).call(this, c2)) {
            done = false;
            __privateMethod(this, _AST_instances, adoptWithSpace_fn).call(this, c2, i2);
          } else if (__privateMethod(this, _AST_instances, canUsurp_fn).call(this, c2)) {
            done = false;
            __privateMethod(this, _AST_instances, usurp_fn).call(this, c2);
          }
        }
      }
    } while (!done && ++iterations < 10);
  }
  __privateSet(this, _toString, void 0);
};
partsToRegExp_fn = function(dot) {
  return __privateGet(this, _parts).map((p2) => {
    if (typeof p2 === "string") {
      throw new Error("string type in extglob ast??");
    }
    const [re, _2, _hasMagic2, uflag] = p2.toRegExpSource(dot);
    __privateSet(this, _uflag, __privateGet(this, _uflag) || uflag);
    return re;
  }).filter((p2) => !(this.isStart() && this.isEnd()) || !!p2).join("|");
};
parseGlob_fn = function(glob, hasMagic, noEmpty = false) {
  let escaping = false;
  let re = "";
  let uflag = false;
  let inStar = false;
  for (let i2 = 0; i2 < glob.length; i2++) {
    const c2 = glob.charAt(i2);
    if (escaping) {
      escaping = false;
      re += (reSpecials.has(c2) ? "\\" : "") + c2;
      continue;
    }
    if (c2 === "*") {
      if (inStar)
        continue;
      inStar = true;
      re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
      hasMagic = true;
      continue;
    } else {
      inStar = false;
    }
    if (c2 === "\\") {
      if (i2 === glob.length - 1) {
        re += "\\\\";
      } else {
        escaping = true;
      }
      continue;
    }
    if (c2 === "[") {
      const [src, needUflag, consumed, magic] = parseClass(glob, i2);
      if (consumed) {
        re += src;
        uflag = uflag || needUflag;
        i2 += consumed - 1;
        hasMagic = hasMagic || magic;
        continue;
      }
    }
    if (c2 === "?") {
      re += qmark;
      hasMagic = true;
      continue;
    }
    re += regExpEscape(c2);
  }
  return [re, unescape(glob), !!hasMagic, uflag];
};
__privateAdd(AST, _AST_static);
_a = AST;

// node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/escape.js
var escape = (s2, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
  if (magicalBraces) {
    return windowsPathsNoEscape ? s2.replace(/[?*()[\]{}]/g, "[$&]") : s2.replace(/[?*()[\]\\{}]/g, "\\$&");
  }
  return windowsPathsNoEscape ? s2.replace(/[?*()[\]]/g, "[$&]") : s2.replace(/[?*()[\]\\]/g, "\\$&");
};

// node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js
var minimatch = (p2, pattern, options = {}) => {
  assertValidPattern(pattern);
  if (!options.nocomment && pattern.charAt(0) === "#") {
    return false;
  }
  return new Minimatch(pattern, options).match(p2);
};
var starDotExtRE = /^\*+([^+@!?*[(]*)$/;
var starDotExtTest = (ext2) => (f2) => !f2.startsWith(".") && f2.endsWith(ext2);
var starDotExtTestDot = (ext2) => (f2) => f2.endsWith(ext2);
var starDotExtTestNocase = (ext2) => {
  ext2 = ext2.toLowerCase();
  return (f2) => !f2.startsWith(".") && f2.toLowerCase().endsWith(ext2);
};
var starDotExtTestNocaseDot = (ext2) => {
  ext2 = ext2.toLowerCase();
  return (f2) => f2.toLowerCase().endsWith(ext2);
};
var starDotStarRE = /^\*+\.\*+$/;
var starDotStarTest = (f2) => !f2.startsWith(".") && f2.includes(".");
var starDotStarTestDot = (f2) => f2 !== "." && f2 !== ".." && f2.includes(".");
var dotStarRE = /^\.\*+$/;
var dotStarTest = (f2) => f2 !== "." && f2 !== ".." && f2.startsWith(".");
var starRE = /^\*+$/;
var starTest = (f2) => f2.length !== 0 && !f2.startsWith(".");
var starTestDot = (f2) => f2.length !== 0 && f2 !== "." && f2 !== "..";
var qmarksRE = /^\?+([^+@!?*[(]*)?$/;
var qmarksTestNocase = ([$0, ext2 = ""]) => {
  const noext = qmarksTestNoExt([$0]);
  if (!ext2)
    return noext;
  ext2 = ext2.toLowerCase();
  return (f2) => noext(f2) && f2.toLowerCase().endsWith(ext2);
};
var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
  const noext = qmarksTestNoExtDot([$0]);
  if (!ext2)
    return noext;
  ext2 = ext2.toLowerCase();
  return (f2) => noext(f2) && f2.toLowerCase().endsWith(ext2);
};
var qmarksTestDot = ([$0, ext2 = ""]) => {
  const noext = qmarksTestNoExtDot([$0]);
  return !ext2 ? noext : (f2) => noext(f2) && f2.endsWith(ext2);
};
var qmarksTest = ([$0, ext2 = ""]) => {
  const noext = qmarksTestNoExt([$0]);
  return !ext2 ? noext : (f2) => noext(f2) && f2.endsWith(ext2);
};
var qmarksTestNoExt = ([$0]) => {
  const len = $0.length;
  return (f2) => f2.length === len && !f2.startsWith(".");
};
var qmarksTestNoExtDot = ([$0]) => {
  const len = $0.length;
  return (f2) => f2.length === len && f2 !== "." && f2 !== "..";
};
var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
var path = {
  win32: { sep: "\\" },
  posix: { sep: "/" }
};
var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
minimatch.sep = sep;
var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
minimatch.GLOBSTAR = GLOBSTAR;
var qmark2 = "[^/]";
var star2 = qmark2 + "*?";
var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
var filter = (pattern, options = {}) => (p2) => minimatch(p2, pattern, options);
minimatch.filter = filter;
var ext = (a2, b2 = {}) => Object.assign({}, a2, b2);
var defaults = (def) => {
  if (!def || typeof def !== "object" || !Object.keys(def).length) {
    return minimatch;
  }
  const orig = minimatch;
  const m2 = (p2, pattern, options = {}) => orig(p2, pattern, ext(def, options));
  return Object.assign(m2, {
    Minimatch: class Minimatch extends orig.Minimatch {
      constructor(pattern, options = {}) {
        super(pattern, ext(def, options));
      }
      static defaults(options) {
        return orig.defaults(ext(def, options)).Minimatch;
      }
    },
    AST: class AST extends orig.AST {
      /* c8 ignore start */
      constructor(type, parent, options = {}) {
        super(type, parent, ext(def, options));
      }
      /* c8 ignore stop */
      static fromGlob(pattern, options = {}) {
        return orig.AST.fromGlob(pattern, ext(def, options));
      }
    },
    unescape: (s2, options = {}) => orig.unescape(s2, ext(def, options)),
    escape: (s2, options = {}) => orig.escape(s2, ext(def, options)),
    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
    defaults: (options) => orig.defaults(ext(def, options)),
    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
    sep: orig.sep,
    GLOBSTAR
  });
};
minimatch.defaults = defaults;
var braceExpand = (pattern, options = {}) => {
  assertValidPattern(pattern);
  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
    return [pattern];
  }
  return expand(pattern, { max: options.braceExpandMax });
};
minimatch.braceExpand = braceExpand;
var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
minimatch.makeRe = makeRe;
var match = (list, pattern, options = {}) => {
  const mm = new Minimatch(pattern, options);
  list = list.filter((f2) => mm.match(f2));
  if (mm.options.nonull && !list.length) {
    list.push(pattern);
  }
  return list;
};
minimatch.match = match;
var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
var regExpEscape2 = (s2) => s2.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
var _Minimatch_instances, matchGlobstar_fn, matchGlobStarBodySections_fn, matchOne_fn;
var Minimatch = class {
  constructor(pattern, options = {}) {
    __privateAdd(this, _Minimatch_instances);
    __publicField(this, "options");
    __publicField(this, "set");
    __publicField(this, "pattern");
    __publicField(this, "windowsPathsNoEscape");
    __publicField(this, "nonegate");
    __publicField(this, "negate");
    __publicField(this, "comment");
    __publicField(this, "empty");
    __publicField(this, "preserveMultipleSlashes");
    __publicField(this, "partial");
    __publicField(this, "globSet");
    __publicField(this, "globParts");
    __publicField(this, "nocase");
    __publicField(this, "isWindows");
    __publicField(this, "platform");
    __publicField(this, "windowsNoMagicRoot");
    __publicField(this, "maxGlobstarRecursion");
    __publicField(this, "regexp");
    var _a2;
    assertValidPattern(pattern);
    options = options || {};
    this.options = options;
    this.maxGlobstarRecursion = (_a2 = options.maxGlobstarRecursion) != null ? _a2 : 200;
    this.pattern = pattern;
    this.platform = options.platform || defaultPlatform;
    this.isWindows = this.platform === "win32";
    const awe = "allowWindowsEscape";
    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
    if (this.windowsPathsNoEscape) {
      this.pattern = this.pattern.replace(/\\/g, "/");
    }
    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
    this.regexp = null;
    this.negate = false;
    this.nonegate = !!options.nonegate;
    this.comment = false;
    this.empty = false;
    this.partial = !!options.partial;
    this.nocase = !!this.options.nocase;
    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
    this.globSet = [];
    this.globParts = [];
    this.set = [];
    this.make();
  }
  hasMagic() {
    if (this.options.magicalBraces && this.set.length > 1) {
      return true;
    }
    for (const pattern of this.set) {
      for (const part of pattern) {
        if (typeof part !== "string")
          return true;
      }
    }
    return false;
  }
  debug(..._2) {
  }
  make() {
    const pattern = this.pattern;
    const options = this.options;
    if (!options.nocomment && pattern.charAt(0) === "#") {
      this.comment = true;
      return;
    }
    if (!pattern) {
      this.empty = true;
      return;
    }
    this.parseNegate();
    this.globSet = [...new Set(this.braceExpand())];
    if (options.debug) {
      this.debug = (...args) => console.error(...args);
    }
    this.debug(this.pattern, this.globSet);
    const rawGlobParts = this.globSet.map((s2) => this.slashSplit(s2));
    this.globParts = this.preprocess(rawGlobParts);
    this.debug(this.pattern, this.globParts);
    let set2 = this.globParts.map((s2, _2, __) => {
      if (this.isWindows && this.windowsNoMagicRoot) {
        const isUNC = s2[0] === "" && s2[1] === "" && (s2[2] === "?" || !globMagic.test(s2[2])) && !globMagic.test(s2[3]);
        const isDrive = /^[a-z]:/i.test(s2[0]);
        if (isUNC) {
          return [
            ...s2.slice(0, 4),
            ...s2.slice(4).map((ss) => this.parse(ss))
          ];
        } else if (isDrive) {
          return [s2[0], ...s2.slice(1).map((ss) => this.parse(ss))];
        }
      }
      return s2.map((ss) => this.parse(ss));
    });
    this.debug(this.pattern, set2);
    this.set = set2.filter((s2) => s2.indexOf(false) === -1);
    if (this.isWindows) {
      for (let i2 = 0; i2 < this.set.length; i2++) {
        const p2 = this.set[i2];
        if (p2[0] === "" && p2[1] === "" && this.globParts[i2][2] === "?" && typeof p2[3] === "string" && /^[a-z]:$/i.test(p2[3])) {
          p2[2] = "?";
        }
      }
    }
    this.debug(this.pattern, this.set);
  }
  // various transforms to equivalent pattern sets that are
  // faster to process in a filesystem walk.  The goal is to
  // eliminate what we can, and push all ** patterns as far
  // to the right as possible, even if it increases the number
  // of patterns that we have to process.
  preprocess(globParts) {
    if (this.options.noglobstar) {
      for (const partset of globParts) {
        for (let j2 = 0; j2 < partset.length; j2++) {
          if (partset[j2] === "**") {
            partset[j2] = "*";
          }
        }
      }
    }
    const { optimizationLevel = 1 } = this.options;
    if (optimizationLevel >= 2) {
      globParts = this.firstPhasePreProcess(globParts);
      globParts = this.secondPhasePreProcess(globParts);
    } else if (optimizationLevel >= 1) {
      globParts = this.levelOneOptimize(globParts);
    } else {
      globParts = this.adjascentGlobstarOptimize(globParts);
    }
    return globParts;
  }
  // just get rid of adjascent ** portions
  adjascentGlobstarOptimize(globParts) {
    return globParts.map((parts) => {
      let gs = -1;
      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
        let i2 = gs;
        while (parts[i2 + 1] === "**") {
          i2++;
        }
        if (i2 !== gs) {
          parts.splice(gs, i2 - gs);
        }
      }
      return parts;
    });
  }
  // get rid of adjascent ** and resolve .. portions
  levelOneOptimize(globParts) {
    return globParts.map((parts) => {
      parts = parts.reduce((set2, part) => {
        const prev = set2[set2.length - 1];
        if (part === "**" && prev === "**") {
          return set2;
        }
        if (part === "..") {
          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
            set2.pop();
            return set2;
          }
        }
        set2.push(part);
        return set2;
      }, []);
      return parts.length === 0 ? [""] : parts;
    });
  }
  levelTwoFileOptimize(parts) {
    if (!Array.isArray(parts)) {
      parts = this.slashSplit(parts);
    }
    let didSomething = false;
    do {
      didSomething = false;
      if (!this.preserveMultipleSlashes) {
        for (let i2 = 1; i2 < parts.length - 1; i2++) {
          const p2 = parts[i2];
          if (i2 === 1 && p2 === "" && parts[0] === "")
            continue;
          if (p2 === "." || p2 === "") {
            didSomething = true;
            parts.splice(i2, 1);
            i2--;
          }
        }
        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
          didSomething = true;
          parts.pop();
        }
      }
      let dd = 0;
      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
        const p2 = parts[dd - 1];
        if (p2 && p2 !== "." && p2 !== ".." && p2 !== "**" && !(this.isWindows && /^[a-z]:$/i.test(p2))) {
          didSomething = true;
          parts.splice(dd - 1, 2);
          dd -= 2;
        }
      }
    } while (didSomething);
    return parts.length === 0 ? [""] : parts;
  }
  // First phase: single-pattern processing
  // <pre> is 1 or more portions
  // <rest> is 1 or more portions
  // <p> is any portion other than ., .., '', or **
  // <e> is . or ''
  //
  // **/.. is *brutal* for filesystem walking performance, because
  // it effectively resets the recursive walk each time it occurs,
  // and ** cannot be reduced out by a .. pattern part like a regexp
  // or most strings (other than .., ., and '') can be.
  //
  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
  // <pre>/<e>/<rest> -> <pre>/<rest>
  // <pre>/<p>/../<rest> -> <pre>/<rest>
  // **/**/<rest> -> **/<rest>
  //
  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
  // this WOULD be allowed if ** did follow symlinks, or * didn't
  firstPhasePreProcess(globParts) {
    let didSomething = false;
    do {
      didSomething = false;
      for (let parts of globParts) {
        let gs = -1;
        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
          let gss = gs;
          while (parts[gss + 1] === "**") {
            gss++;
          }
          if (gss > gs) {
            parts.splice(gs + 1, gss - gs);
          }
          let next = parts[gs + 1];
          const p2 = parts[gs + 2];
          const p22 = parts[gs + 3];
          if (next !== "..")
            continue;
          if (!p2 || p2 === "." || p2 === ".." || !p22 || p22 === "." || p22 === "..") {
            continue;
          }
          didSomething = true;
          parts.splice(gs, 1);
          const other = parts.slice(0);
          other[gs] = "**";
          globParts.push(other);
          gs--;
        }
        if (!this.preserveMultipleSlashes) {
          for (let i2 = 1; i2 < parts.length - 1; i2++) {
            const p2 = parts[i2];
            if (i2 === 1 && p2 === "" && parts[0] === "")
              continue;
            if (p2 === "." || p2 === "") {
              didSomething = true;
              parts.splice(i2, 1);
              i2--;
            }
          }
          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
            didSomething = true;
            parts.pop();
          }
        }
        let dd = 0;
        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
          const p2 = parts[dd - 1];
          if (p2 && p2 !== "." && p2 !== ".." && p2 !== "**") {
            didSomething = true;
            const needDot = dd === 1 && parts[dd + 1] === "**";
            const splin = needDot ? ["."] : [];
            parts.splice(dd - 1, 2, ...splin);
            if (parts.length === 0)
              parts.push("");
            dd -= 2;
          }
        }
      }
    } while (didSomething);
    return globParts;
  }
  // second phase: multi-pattern dedupes
  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
  //
  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
  // ^-- not valid because ** doens't follow symlinks
  secondPhasePreProcess(globParts) {
    for (let i2 = 0; i2 < globParts.length - 1; i2++) {
      for (let j2 = i2 + 1; j2 < globParts.length; j2++) {
        const matched = this.partsMatch(globParts[i2], globParts[j2], !this.preserveMultipleSlashes);
        if (matched) {
          globParts[i2] = [];
          globParts[j2] = matched;
          break;
        }
      }
    }
    return globParts.filter((gs) => gs.length);
  }
  partsMatch(a2, b2, emptyGSMatch = false) {
    let ai = 0;
    let bi = 0;
    let result = [];
    let which = "";
    while (ai < a2.length && bi < b2.length) {
      if (a2[ai] === b2[bi]) {
        result.push(which === "b" ? b2[bi] : a2[ai]);
        ai++;
        bi++;
      } else if (emptyGSMatch && a2[ai] === "**" && b2[bi] === a2[ai + 1]) {
        result.push(a2[ai]);
        ai++;
      } else if (emptyGSMatch && b2[bi] === "**" && a2[ai] === b2[bi + 1]) {
        result.push(b2[bi]);
        bi++;
      } else if (a2[ai] === "*" && b2[bi] && (this.options.dot || !b2[bi].startsWith(".")) && b2[bi] !== "**") {
        if (which === "b")
          return false;
        which = "a";
        result.push(a2[ai]);
        ai++;
        bi++;
      } else if (b2[bi] === "*" && a2[ai] && (this.options.dot || !a2[ai].startsWith(".")) && a2[ai] !== "**") {
        if (which === "a")
          return false;
        which = "b";
        result.push(b2[bi]);
        ai++;
        bi++;
      } else {
        return false;
      }
    }
    return a2.length === b2.length && result;
  }
  parseNegate() {
    if (this.nonegate)
      return;
    const pattern = this.pattern;
    let negate = false;
    let negateOffset = 0;
    for (let i2 = 0; i2 < pattern.length && pattern.charAt(i2) === "!"; i2++) {
      negate = !negate;
      negateOffset++;
    }
    if (negateOffset)
      this.pattern = pattern.slice(negateOffset);
    this.negate = negate;
  }
  // set partial to true to test if, for example,
  // "/a/b" matches the start of "/*/b/*/d"
  // Partial means, if you run out of file before you run
  // out of pattern, then that's fine, as long as all
  // the parts match.
  matchOne(file, pattern, partial = false) {
    let fileStartIndex = 0;
    let patternStartIndex = 0;
    if (this.isWindows) {
      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
      if (typeof fdi === "number" && typeof pdi === "number") {
        const [fd, pd] = [
          file[fdi],
          pattern[pdi]
        ];
        if (fd.toLowerCase() === pd.toLowerCase()) {
          pattern[pdi] = fd;
          patternStartIndex = pdi;
          fileStartIndex = fdi;
        }
      }
    }
    const { optimizationLevel = 1 } = this.options;
    if (optimizationLevel >= 2) {
      file = this.levelTwoFileOptimize(file);
    }
    if (pattern.includes(GLOBSTAR)) {
      return __privateMethod(this, _Minimatch_instances, matchGlobstar_fn).call(this, file, pattern, partial, fileStartIndex, patternStartIndex);
    }
    return __privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file, pattern, partial, fileStartIndex, patternStartIndex);
  }
  braceExpand() {
    return braceExpand(this.pattern, this.options);
  }
  parse(pattern) {
    assertValidPattern(pattern);
    const options = this.options;
    if (pattern === "**")
      return GLOBSTAR;
    if (pattern === "")
      return "";
    let m2;
    let fastTest = null;
    if (m2 = pattern.match(starRE)) {
      fastTest = options.dot ? starTestDot : starTest;
    } else if (m2 = pattern.match(starDotExtRE)) {
      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m2[1]);
    } else if (m2 = pattern.match(qmarksRE)) {
      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m2);
    } else if (m2 = pattern.match(starDotStarRE)) {
      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
    } else if (m2 = pattern.match(dotStarRE)) {
      fastTest = dotStarTest;
    }
    const re = AST.fromGlob(pattern, this.options).toMMPattern();
    if (fastTest && typeof re === "object") {
      Reflect.defineProperty(re, "test", { value: fastTest });
    }
    return re;
  }
  makeRe() {
    if (this.regexp || this.regexp === false)
      return this.regexp;
    const set2 = this.set;
    if (!set2.length) {
      this.regexp = false;
      return this.regexp;
    }
    const options = this.options;
    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
    const flags = new Set(options.nocase ? ["i"] : []);
    let re = set2.map((pattern) => {
      const pp = pattern.map((p2) => {
        if (p2 instanceof RegExp) {
          for (const f2 of p2.flags.split(""))
            flags.add(f2);
        }
        return typeof p2 === "string" ? regExpEscape2(p2) : p2 === GLOBSTAR ? GLOBSTAR : p2._src;
      });
      pp.forEach((p2, i2) => {
        const next = pp[i2 + 1];
        const prev = pp[i2 - 1];
        if (p2 !== GLOBSTAR || prev === GLOBSTAR) {
          return;
        }
        if (prev === void 0) {
          if (next !== void 0 && next !== GLOBSTAR) {
            pp[i2 + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
          } else {
            pp[i2] = twoStar;
          }
        } else if (next === void 0) {
          pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
        } else if (next !== GLOBSTAR) {
          pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
          pp[i2 + 1] = GLOBSTAR;
        }
      });
      const filtered = pp.filter((p2) => p2 !== GLOBSTAR);
      if (this.partial && filtered.length >= 1) {
        const prefixes = [];
        for (let i2 = 1; i2 <= filtered.length; i2++) {
          prefixes.push(filtered.slice(0, i2).join("/"));
        }
        return "(?:" + prefixes.join("|") + ")";
      }
      return filtered.join("/");
    }).join("|");
    const [open, close] = set2.length > 1 ? ["(?:", ")"] : ["", ""];
    re = "^" + open + re + close + "$";
    if (this.partial) {
      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
    }
    if (this.negate)
      re = "^(?!" + re + ").+$";
    try {
      this.regexp = new RegExp(re, [...flags].join(""));
    } catch (e2) {
      this.regexp = false;
    }
    return this.regexp;
  }
  slashSplit(p2) {
    if (this.preserveMultipleSlashes) {
      return p2.split("/");
    } else if (this.isWindows && /^\/\/[^/]+/.test(p2)) {
      return ["", ...p2.split(/\/+/)];
    } else {
      return p2.split(/\/+/);
    }
  }
  match(f2, partial = this.partial) {
    this.debug("match", f2, this.pattern);
    if (this.comment) {
      return false;
    }
    if (this.empty) {
      return f2 === "";
    }
    if (f2 === "/" && partial) {
      return true;
    }
    const options = this.options;
    if (this.isWindows) {
      f2 = f2.split("\\").join("/");
    }
    const ff = this.slashSplit(f2);
    this.debug(this.pattern, "split", ff);
    const set2 = this.set;
    this.debug(this.pattern, "set", set2);
    let filename = ff[ff.length - 1];
    if (!filename) {
      for (let i2 = ff.length - 2; !filename && i2 >= 0; i2--) {
        filename = ff[i2];
      }
    }
    for (const pattern of set2) {
      let file = ff;
      if (options.matchBase && pattern.length === 1) {
        file = [filename];
      }
      const hit = this.matchOne(file, pattern, partial);
      if (hit) {
        if (options.flipNegate) {
          return true;
        }
        return !this.negate;
      }
    }
    if (options.flipNegate) {
      return false;
    }
    return this.negate;
  }
  static defaults(def) {
    return minimatch.defaults(def).Minimatch;
  }
};
_Minimatch_instances = new WeakSet();
matchGlobstar_fn = function(file, pattern, partial, fileIndex, patternIndex) {
  const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
  const lastgs = pattern.lastIndexOf(GLOBSTAR);
  const [head, body, tail] = partial ? [
    pattern.slice(patternIndex, firstgs),
    pattern.slice(firstgs + 1),
    []
  ] : [
    pattern.slice(patternIndex, firstgs),
    pattern.slice(firstgs + 1, lastgs),
    pattern.slice(lastgs + 1)
  ];
  if (head.length) {
    const fileHead = file.slice(fileIndex, fileIndex + head.length);
    if (!__privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, fileHead, head, partial, 0, 0)) {
      return false;
    }
    fileIndex += head.length;
    patternIndex += head.length;
  }
  let fileTailMatch = 0;
  if (tail.length) {
    if (tail.length + fileIndex > file.length)
      return false;
    let tailStart = file.length - tail.length;
    if (__privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file, tail, partial, tailStart, 0)) {
      fileTailMatch = tail.length;
    } else {
      if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
        return false;
      }
      tailStart--;
      if (!__privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file, tail, partial, tailStart, 0)) {
        return false;
      }
      fileTailMatch = tail.length + 1;
    }
  }
  if (!body.length) {
    let sawSome = !!fileTailMatch;
    for (let i3 = fileIndex; i3 < file.length - fileTailMatch; i3++) {
      const f2 = String(file[i3]);
      sawSome = true;
      if (f2 === "." || f2 === ".." || !this.options.dot && f2.startsWith(".")) {
        return false;
      }
    }
    return partial || sawSome;
  }
  const bodySegments = [[[], 0]];
  let currentBody = bodySegments[0];
  let nonGsParts = 0;
  const nonGsPartsSums = [0];
  for (const b2 of body) {
    if (b2 === GLOBSTAR) {
      nonGsPartsSums.push(nonGsParts);
      currentBody = [[], 0];
      bodySegments.push(currentBody);
    } else {
      currentBody[0].push(b2);
      nonGsParts++;
    }
  }
  let i2 = bodySegments.length - 1;
  const fileLength = file.length - fileTailMatch;
  for (const b2 of bodySegments) {
    b2[1] = fileLength - (nonGsPartsSums[i2--] + b2[0].length);
  }
  return !!__privateMethod(this, _Minimatch_instances, matchGlobStarBodySections_fn).call(this, file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
};
// return false for "nope, not matching"
// return null for "not matching, cannot keep trying"
matchGlobStarBodySections_fn = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
  const bs = bodySegments[bodyIndex];
  if (!bs) {
    for (let i2 = fileIndex; i2 < file.length; i2++) {
      sawTail = true;
      const f2 = file[i2];
      if (f2 === "." || f2 === ".." || !this.options.dot && f2.startsWith(".")) {
        return false;
      }
    }
    return sawTail;
  }
  const [body, after] = bs;
  while (fileIndex <= after) {
    const m2 = __privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
    if (m2 && globStarDepth < this.maxGlobstarRecursion) {
      const sub = __privateMethod(this, _Minimatch_instances, matchGlobStarBodySections_fn).call(this, file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
      if (sub !== false) {
        return sub;
      }
    }
    const f2 = file[fileIndex];
    if (f2 === "." || f2 === ".." || !this.options.dot && f2.startsWith(".")) {
      return false;
    }
    fileIndex++;
  }
  return partial || null;
};
matchOne_fn = function(file, pattern, partial, fileIndex, patternIndex) {
  let fi;
  let pi;
  let pl2;
  let fl;
  for (fi = fileIndex, pi = patternIndex, fl = file.length, pl2 = pattern.length; fi < fl && pi < pl2; fi++, pi++) {
    this.debug("matchOne loop");
    let p2 = pattern[pi];
    let f2 = file[fi];
    this.debug(pattern, p2, f2);
    if (p2 === false || p2 === GLOBSTAR) {
      return false;
    }
    let hit;
    if (typeof p2 === "string") {
      hit = f2 === p2;
      this.debug("string match", p2, f2, hit);
    } else {
      hit = p2.test(f2);
      this.debug("pattern match", p2, f2, hit);
    }
    if (!hit)
      return false;
  }
  if (fi === fl && pi === pl2) {
    return true;
  } else if (fi === fl) {
    return partial;
  } else if (pi === pl2) {
    return fi === fl - 1 && file[fi] === "";
  } else {
    throw new Error("wtf?");
  }
};
minimatch.AST = AST;
minimatch.Minimatch = Minimatch;
minimatch.escape = escape;
minimatch.unescape = unescape;

// src/utils/fs.ts
function isSupportedFileType(path2) {
  return path2.split(".").pop().toLowerCase() === "md";
}
function pathMatchesPattern(path2, pattern) {
  return path2.startsWith(pattern) || minimatch(path2, pattern);
}

// src/data/settings.ts
var DEFAULT_SETTINGS = {
  // flashcards
  flashcardTags: ["#flashcards"],
  flashcardTagsToIgnore: [],
  convertFoldersToDecks: false,
  burySiblingCards: false,
  flashcardCardOrder: "DueFirstRandom",
  flashcardDeckOrder: "PrevDeckComplete_Sequential",
  convertClozePatternsToInputs: false,
  convertHighlightsToClozes: true,
  convertBoldTextToClozes: false,
  convertCurlyBracketsToClozes: false,
  clozePatterns: ["==[123;;]answer[;;hint]=="],
  singleLineCardSeparator: "::",
  singleLineReversedCardSeparator: ":::",
  multilineCardSeparator: "?",
  multilineReversedCardSeparator: "??",
  multilineCardEndMarker: "",
  editLaterTag: void 0,
  enableReviewReminders: false,
  reviewReminderIntervalMinutes: 5,
  reviewReminderCheckOnStartup: false,
  reviewReminderMessage: "",
  reviewReminderAutoOpen: true,
  reviewReminderShowNotice: true,
  reviewReminderPlaySound: true,
  reviewReminderBounceDock: true,
  randomizeCardOrder: void 0,
  // notes
  enableNoteReviewPaneOnStartup: true,
  tagsToReview: ["#review"],
  noteTagsToIgnore: [],
  noteFoldersToIgnore: ["**/*.excalidraw.md"],
  openRandomNote: false,
  autoNextNote: false,
  disableFileMenuReviewOptions: void 0,
  showFileMenuReviewOptions: true,
  deleteTagsOnSchedulingDataDeletion: false,
  maxNDaysNotesReviewQueue: 365,
  // UI settings
  showRibbonIcon: true,
  showStatusBar: true,
  showCardStatusBarItem: true,
  showNoteStatusBarItem: true,
  showUpdateAvailableStatusBarItem: true,
  initiallyExpandAllSubdecksInTree: true,
  showContextInCards: true,
  showIntervalInReviewButtons: true,
  flashcardHeightPercentage: 60,
  flashcardWidthPercentage: 60,
  flashcardHeightPercentageMobile: 100,
  flashcardWidthPercentageMobile: 100,
  flashcardAgainText: t("AGAIN"),
  flashcardEasyText: t("EASY"),
  flashcardGoodText: t("GOOD"),
  flashcardHardText: t("HARD"),
  reviewButtonDelay: 0,
  showDeleteButtonInCardView: false,
  showDeleteButtonInFileMenu: false,
  openViewInNewTab: false,
  openViewInNewTabMobile: false,
  useCustomHotkeys: false,
  useCalloutsForSchedulingComments: false,
  // algorithm
  algorithm: "SM-2-OSR" /* SM_2_OSR */,
  baseEase: 250,
  lapsesIntervalChange: 0.5,
  easyBonus: 1.3,
  loadBalance: true,
  maximumInterval: 36525,
  maxLinkFactor: 1,
  fsrsDesiredRetention: 0.9,
  startOfDay: "00:00:00",
  // storage
  dataStore: "NOTES" /* NOTES */,
  cardCommentOnSameLine: false,
  scheduleDataVaultLocation: "Spaced Repetition",
  // logging
  showSchedulingDebugMessages: false,
  showParserDebugMessages: false,
  preferredDateFormatForNoteReviewQueue: "MMM DD YYYY",
  preferredLocale: "-"
};
function upgradeSettings(settings) {
  if (settings.randomizeCardOrder !== null && settings.randomizeCardOrder !== void 0 && (settings.flashcardCardOrder === null || settings.flashcardCardOrder === void 0) && (settings.flashcardDeckOrder === null || settings.flashcardDeckOrder === void 0)) {
    settings.flashcardCardOrder = settings.randomizeCardOrder ? "DueFirstRandom" : "DueFirstSequential";
    settings.flashcardDeckOrder = "PrevDeckComplete_Sequential";
    settings.randomizeCardOrder = void 0;
  }
  if (settings.clozePatterns === null || settings.clozePatterns === void 0) {
    settings.clozePatterns = [];
    if (settings.convertHighlightsToClozes)
      settings.clozePatterns.push("==[123;;]answer[;;hint]==");
    if (settings.convertBoldTextToClozes)
      settings.clozePatterns.push("**[123;;]answer[;;hint]**");
    if (settings.convertCurlyBracketsToClozes)
      settings.clozePatterns.push("{{[123;;]answer[;;hint]}}");
  }
  if (settings.disableFileMenuReviewOptions !== void 0) {
    settings.disableFileMenuReviewOptions = void 0;
  }
  if (settings.editLaterTag) {
    settings.editLaterTag = void 0;
  }
  if (settings.scheduleDataVaultLocation === null || settings.scheduleDataVaultLocation === void 0 || settings.scheduleDataVaultLocation.trim() === "") {
    settings.scheduleDataVaultLocation = DEFAULT_SETTINGS.scheduleDataVaultLocation;
  }
  if (settings.fsrsDesiredRetention === null || settings.fsrsDesiredRetention === void 0) {
    settings.fsrsDesiredRetention = DEFAULT_SETTINGS.fsrsDesiredRetention;
  }
  if (settings.enableReviewReminders === null || settings.enableReviewReminders === void 0) {
    settings.enableReviewReminders = DEFAULT_SETTINGS.enableReviewReminders;
  }
  if (settings.reviewReminderIntervalMinutes === null || settings.reviewReminderIntervalMinutes === void 0 || settings.reviewReminderIntervalMinutes < 1) {
    settings.reviewReminderIntervalMinutes = DEFAULT_SETTINGS.reviewReminderIntervalMinutes;
  }
  if (settings.reviewReminderCheckOnStartup === null || settings.reviewReminderCheckOnStartup === void 0) {
    settings.reviewReminderCheckOnStartup = DEFAULT_SETTINGS.reviewReminderCheckOnStartup;
  }
  if (settings.reviewReminderMessage === null || settings.reviewReminderMessage === void 0) {
    settings.reviewReminderMessage = DEFAULT_SETTINGS.reviewReminderMessage;
  }
  if (settings.reviewReminderAutoOpen === null || settings.reviewReminderAutoOpen === void 0) {
    settings.reviewReminderAutoOpen = DEFAULT_SETTINGS.reviewReminderAutoOpen;
  }
  if (settings.reviewReminderShowNotice === null || settings.reviewReminderShowNotice === void 0) {
    settings.reviewReminderShowNotice = DEFAULT_SETTINGS.reviewReminderShowNotice;
  }
  if (settings.reviewReminderPlaySound === null || settings.reviewReminderPlaySound === void 0) {
    settings.reviewReminderPlaySound = DEFAULT_SETTINGS.reviewReminderPlaySound;
  }
  if (settings.reviewReminderBounceDock === null || settings.reviewReminderBounceDock === void 0) {
    settings.reviewReminderBounceDock = DEFAULT_SETTINGS.reviewReminderBounceDock;
  }
}
var SettingsUtil = class _SettingsUtil {
  static isFlashcardTag(settings, tag) {
    return _SettingsUtil.isTagInList(settings.flashcardTags, tag);
  }
  static isPathInFoldersToIgnore(settings, path2) {
    return settings.noteFoldersToIgnore.some((folder) => pathMatchesPattern(path2, folder));
  }
  static isAnyTagANoteReviewTag(settings, tags) {
    for (const tag of tags) {
      if (settings.tagsToReview.some(
        (tagToReview) => this.isSubTagContainedInTag(tagToReview, tag)
      )) {
        return true;
      }
    }
    return false;
  }
  static isAnyTagIgnoredForFlashcards(settings, tags) {
    return tags.some((tag) => _SettingsUtil.isTagInList(settings.flashcardTagsToIgnore, tag));
  }
  static isAnyTagIgnoredForNotes(settings, tags) {
    return tags.some((tag) => _SettingsUtil.isTagInList(settings.noteTagsToIgnore, tag));
  }
  // Given a list of tags, return the subset that is in settings.tagsToReview
  static filterForNoteReviewTag(settings, tags) {
    const result = [];
    for (const tagToReview of settings.tagsToReview) {
      if (tags.some((tag) => this.isSubTagContainedInTag(tagToReview, tag))) {
        result.push(tagToReview);
      }
    }
    return result;
  }
  /**
   * Checks if the tag is in the tagList.
   *
   * @param tagList - The list of tags to check.
   * @param tag - The tag to check.
   * @param exactMatch - Whether to match the tag exactly or if it should be a sub tag.
   * @returns true if the tag is in the tagList, false otherwise.
   */
  static isTagInList(tagList, tag, exactMatch = false) {
    for (const tagFromList of tagList) {
      if (exactMatch) {
        if (tagFromList === tag) {
          return true;
        }
      } else {
        if (this.isSubTagContainedInTag(tagFromList, tag)) {
          return true;
        }
      }
    }
    return false;
  }
  /**
   * Checks if the subTag is contained in the tag.
   *
   * @param tag - The tag to check.
   * @param subTag - The subTag to check.
   * @returns true if the subTag is contained in the tag, false otherwise.
   */
  static isSubTagContainedInTag(tag, subTag) {
    if (tag === subTag || subTag.startsWith(tag + "/")) {
      return true;
    }
    return false;
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/settings-page.tsx
var import_obsidian19 = require("obsidian");
var SettingsPage = class {
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, applySettingsUpdate, display, openPage, scrollListener) {
    this.plugin = plugin;
    this.settingsManager = settingsManager;
    this.dataManager = dataManager;
    this.pageType = pageType;
    this.display = display;
    this.applySettingsUpdate = applySettingsUpdate;
    this.openPage = openPage;
    this.scrollListener = scrollListener;
    this.pageContainerEl = pageContainerEl;
    this.pageContainerEl.addClass("sr-settings-page");
    this.pageContainerEl.addClass("sr-is-hidden");
    this.pageHeaderEl = this.pageContainerEl.createDiv();
    this.pageHeaderEl.addClass("sr-settings-page-header");
    this.pageHeaderEl.addEventListener("click", () => {
      this.backToMainPage();
    });
    if (pageType === "main-page") this.pageHeaderEl.addClass("sr-is-hidden");
    this.backButton = new import_obsidian19.ButtonComponent(this.pageHeaderEl);
    this.backButton.setClass("sr-settings-page-back-button");
    this.backButton.setClass("clickable-icon");
    this.backButton.setIcon("chevron-left");
    this.backButton.onClick(() => {
      this.backToMainPage();
    });
    this.titleWrapperEl = this.pageHeaderEl.createDiv();
    this.titleWrapperEl.addClass("sr-settings-page-title-wrapper");
    this.titleIconEl = this.titleWrapperEl.createDiv();
    this.titleIconEl.addClass("sr-settings-page-title-icon");
    (0, import_obsidian19.setIcon)(this.titleIconEl, getPageIcon(pageType));
    this.titleEl = this.titleWrapperEl.createDiv();
    this.titleEl.addClass("sr-settings-page-title");
    this.titleEl.setText(getPageName(pageType));
    this.containerEl = this.pageContainerEl.createDiv();
    this.containerEl.addClass("sr-settings-page-content");
    this.containerEl.addEventListener("scroll", (_2) => {
      this.scrollListener(this.containerEl.scrollTop);
    });
  }
  /**
   * Scrolls to the specified position.
   */
  scrollTo(scrollPosition) {
    this.containerEl.scrollTo({
      top: scrollPosition,
      behavior: "auto"
    });
  }
  /**
   * Gets the SettingsPage type.
   */
  getPageType() {
    return this.pageType;
  }
  /**
   * Destroys the SettingsPage. Run any cleanup code here.
   */
  destroy() {
    this.removeScrollListener();
  }
  /**
   * Removes the scroll listener from the SettingsPage.
   */
  removeScrollListener() {
    this.containerEl.removeEventListener("scroll", (_2) => {
      this.scrollListener(this.containerEl.scrollTop);
    });
  }
  /**
   * Adds the scroll listener to the SettingsPage.
   */
  addScrollListener() {
    this.containerEl.addEventListener("scroll", (_2) => {
      this.scrollListener(this.containerEl.scrollTop);
    });
  }
  /**
   * Shows the SettingsPage.
   */
  show() {
    if (this.pageContainerEl.hasClass("sr-is-hidden")) {
      this.pageContainerEl.removeClass("sr-is-hidden");
      this.addScrollListener();
      if (this.render) this.render();
    }
  }
  /**
   * Hides the SettingsPage.
   */
  hide() {
    if (!this.pageContainerEl.hasClass("sr-is-hidden")) {
      this.pageContainerEl.addClass("sr-is-hidden");
      this.removeScrollListener();
    }
  }
  /**
   * Backs to the main page.
   */
  backToMainPage() {
    this.openPage("main-page");
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/data-page.tsx
var DataPage = class extends SettingsPage {
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, applySettingsUpdate, display, openPage, scrollListener) {
    super(
      pageContainerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      applySettingsUpdate,
      display,
      openPage,
      scrollListener
    );
    const dataStorageGroup = new import_obsidian20.SettingGroup(this.containerEl).setHeading(
      t("GROUP_DATA_STORAGE")
    );
    dataStorageGroup.addSetting((setting) => {
      setting.setName(t("INLINE_SCHEDULING_COMMENTS")).setDesc(t("INLINE_SCHEDULING_COMMENTS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.cardCommentOnSameLine).onChange(async (value) => {
          this.settingsManager.settings.cardCommentOnSameLine = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("USE_CALLOUTS_FOR_SCHEDULING_COMMENTS")).setDesc(t("USE_CALLOUTS_FOR_SCHEDULING_COMMENTS_DESC")).addToggle(
        (toggle) => toggle.setValue(
          this.settingsManager.settings.useCalloutsForSchedulingComments
        ).onChange(async (value) => {
          this.settingsManager.settings.useCalloutsForSchedulingComments = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT")).setDesc(t("MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT_DESC")).addButton((button) => {
        button.setButtonText(t("MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT_BUTTON")).setClass("mod-warning").onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT"),
            t("CONFIRM_MIGRATE_SCHEDULING_COMMENTS_TO_CALLOUT"),
            t("MIGRATING_SCHEDULING_COMMENTS_TO_CALLOUT"),
            async () => {
              await DataStore.instance.fileModifier.migrateCommentsToCallouts();
              this.display();
            }
          ).open();
        });
      });
    });
    new import_obsidian20.SettingGroup(this.containerEl).setHeading(t("DELETE_SCHEDULING_DATA_ALL")).addSetting((setting) => {
      setting.setName(t("DELETE_TAGS_WHEN_DELETING_SCHEDULING_DATA")).setDesc(t("DELETE_TAGS_WHEN_DELETING_SCHEDULING_DATA_DESC")).addToggle(
        (toggle) => toggle.setValue(
          this.settingsManager.settings.deleteTagsOnSchedulingDataDeletion
        ).onChange(async (value) => {
          this.settingsManager.settings.deleteTagsOnSchedulingDataDeletion = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("DELETE_SCHEDULING_DATA_ALL")).setDesc(t("DELETE_SCHEDULING_DATA_ALL_DESC")).addButton((button) => {
        button.setButtonText(t("DELETE")).setClass("mod-warning").onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("DELETE_SCHEDULING_DATA_ALL"),
            t("CONFIRM_SCHEDULING_DATA_ALL_DELETION"),
            t("SCHEDULING_DATA_ALL_DELETION_IN_PROGRESS"),
            async () => {
              const settings = this.settingsManager.settings;
              await DataStore.instance.fileModifier.deleteAllSchedulingData(
                settings.deleteTagsOnSchedulingDataDeletion,
                settings.flashcardTags,
                settings.tagsToReview
              );
            }
          ).open();
        });
      });
    }).addSetting((setting) => {
      setting.setName(t("DELETE_SCHEDULING_DATA_IN_NOTES")).setDesc(t("DELETE_SCHEDULING_DATA_IN_NOTES_DESC")).addButton((button) => {
        button.setButtonText(t("DELETE")).setClass("mod-warning").onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("DELETE_SCHEDULING_DATA_IN_NOTES"),
            t("CONFIRM_SCHEDULING_DATA_IN_NOTES_DELETION"),
            t("SCHEDULING_DATA_IN_NOTES_DELETION_IN_PROGRESS"),
            async () => {
              await DataStore.instance.fileModifier.deleteAllSchedulingDataInNotes(
                this.settingsManager.settings.deleteTagsOnSchedulingDataDeletion,
                this.settingsManager.settings.tagsToReview
              );
            }
          ).open();
        });
      });
    }).addSetting((setting) => {
      setting.setName(t("DELETE_SCHEDULING_DATA_IN_CARDS")).setDesc(t("DELETE_SCHEDULING_DATA_IN_CARDS_DESC")).addButton((button) => {
        button.setButtonText(t("DELETE")).setClass("mod-warning").onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("DELETE_SCHEDULING_DATA_IN_CARDS"),
            t("CONFIRM_SCHEDULING_DATA_IN_CARDS_DELETION"),
            t("SCHEDULING_DATA_IN_CARDS_DELETION_IN_PROGRESS"),
            async () => {
              await DataStore.instance.fileModifier.deleteAllSchedulingDataInCards(
                this.settingsManager.settings.deleteTagsOnSchedulingDataDeletion,
                this.settingsManager.settings.flashcardTags
              );
            }
          ).open();
        });
      });
    });
    new import_obsidian20.SettingGroup(this.containerEl).setHeading(t("GROUP_RESET_SETTINGS")).addSetting((setting) => {
      setting.setName(t("GROUP_RESET_SETTINGS")).setDesc(t("GROUP_RESET_SETTINGS_DESC")).addButton((button) => {
        button.setButtonText(t("RESET_SETTINGS")).setClass("mod-warning").onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("RESET_SETTINGS"),
            t("CONFIRM_RESET_SETTINGS"),
            t("RESET_SETTINGS_CONFIRMATION"),
            async () => {
              await this.settingsManager.saveSettings(DEFAULT_SETTINGS);
              this.display();
            }
          ).open();
        });
      });
    });
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/flashcards-page.tsx
var import_obsidian21 = require("obsidian");
var FlashcardsPage = class extends SettingsPage {
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, didReadMultilineEndMarkerWarning, applySettingsUpdate, display, openPage, scrollListener, changeMultilineEndMarkerWarningState) {
    super(
      pageContainerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      applySettingsUpdate,
      display,
      openPage,
      scrollListener
    );
    new import_obsidian21.SettingGroup(this.containerEl).setHeading(t("GROUP_TAGS_FOLDERS")).addSetting((setting) => {
      setting.setName(t("FLASHCARD_TAGS")).setDesc(t("FLASHCARD_TAGS_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.flashcardTags.join(" ")).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.flashcardTags = value.split(/\s+/);
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("CONVERT_FOLDERS_TO_DECKS")).setDesc(t("CONVERT_FOLDERS_TO_DECKS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.convertFoldersToDecks).onChange(async (value) => {
          this.settingsManager.settings.convertFoldersToDecks = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("BURY_SIBLINGS_TILL_NEXT_DAY")).setDesc(t("BURY_SIBLINGS_TILL_NEXT_DAY_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.burySiblingCards).onChange(async (value) => {
          this.settingsManager.settings.burySiblingCards = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("FLASHCARD_TAGS_TO_IGNORE")).setDesc(t("FLASHCARD_TAGS_TO_IGNORE_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.flashcardTagsToIgnore.join(" ")).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.flashcardTagsToIgnore = value.split(/\s+/).filter((v2) => v2);
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("FOLDERS_TO_IGNORE")).setDesc(t("FOLDERS_TO_IGNORE_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.noteFoldersToIgnore.join("\n")).onChange((value) => {
          this.applySettingsUpdate(async () => {
            this.settingsManager.settings.noteFoldersToIgnore = value.split(/\n+/).map((v2) => v2.trim()).filter((v2) => v2);
            await this.settingsManager.save();
          });
        })
      );
    });
    new import_obsidian21.SettingGroup(this.containerEl).setHeading(t("GROUP_FLASHCARD_REVIEW")).addSetting((setting) => {
      setting.setName(t("BURY_SIBLINGS_TILL_NEXT_DAY")).setDesc(t("BURY_SIBLINGS_TILL_NEXT_DAY_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.burySiblingCards).onChange(async (value) => {
          this.settingsManager.settings.burySiblingCards = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_CARD_ORDER_WITHIN_DECK")).addDropdown(
        (dropdown) => dropdown.addOptions({
          NewFirstSequential: t("REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL"),
          DueFirstSequential: t("REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL"),
          NewFirstRandom: t("REVIEW_CARD_ORDER_NEW_FIRST_RANDOM"),
          DueFirstRandom: t("REVIEW_CARD_ORDER_DUE_FIRST_RANDOM"),
          EveryCardRandomDeckAndCard: t("REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD")
        }).setValue(this.settingsManager.settings.flashcardCardOrder).onChange(async (value) => {
          this.settingsManager.settings.flashcardCardOrder = value;
          await this.settingsManager.save();
          this.display();
        })
      );
    }).addSetting((setting) => {
      const deckOrderEnabled = this.settingsManager.settings.flashcardCardOrder !== "EveryCardRandomDeckAndCard";
      setting.setName(t("REVIEW_DECK_ORDER")).addDropdown(
        (dropdown) => dropdown.addOptions(
          deckOrderEnabled ? {
            // eslint-disable-next-line camelcase
            PrevDeckComplete_Sequential: t(
              "REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL"
            ),
            // eslint-disable-next-line camelcase
            PrevDeckComplete_Random: t(
              "REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM"
            )
          } : {
            EveryCardRandomDeckAndCard: t(
              "REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD"
            )
          }
        ).setValue(
          deckOrderEnabled ? this.settingsManager.settings.flashcardDeckOrder : "EveryCardRandomDeckAndCard"
        ).setDisabled(!deckOrderEnabled).onChange(async (value) => {
          this.settingsManager.settings.flashcardDeckOrder = value;
          await this.settingsManager.save();
        })
      );
    });
    new import_obsidian21.SettingGroup(this.containerEl).setHeading(t("GROUP_FLASHCARD_SEPARATORS")).addSetting((setting) => {
      const convertHighlightsToClozesEl = setting.setName(
        t("CONVERT_HIGHLIGHTS_TO_CLOZES")
      );
      const elements = tHTML(
        "CONVERT_HIGHLIGHTS_TO_CLOZES_DESC",
        {
          defaultPattern: "==[123;;]answer[;;hint]=="
        }
      );
      setting.descEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.descEl.append(elements[i2]);
      }
      convertHighlightsToClozesEl.addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.convertHighlightsToClozes).onChange(async (value) => {
          const defaultHightlightPattern = "==[123;;]answer[;;hint]==";
          const clozePatternSet = new Set(
            this.settingsManager.settings.clozePatterns
          );
          if (value) {
            clozePatternSet.add(defaultHightlightPattern);
          } else {
            clozePatternSet.delete(defaultHightlightPattern);
          }
          this.settingsManager.settings.clozePatterns = [...clozePatternSet];
          this.settingsManager.settings.convertHighlightsToClozes = value;
          await this.settingsManager.save();
          this.display();
        })
      );
    }).addSetting((setting) => {
      const convertBoldTextToClozesEl = setting.setName(t("CONVERT_BOLD_TEXT_TO_CLOZES"));
      const elements = tHTML("CONVERT_BOLD_TEXT_TO_CLOZES_DESC", {
        defaultPattern: "**[123;;]answer[;;hint]**"
      });
      setting.descEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.descEl.append(elements[i2]);
      }
      convertBoldTextToClozesEl.addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.convertBoldTextToClozes).onChange(async (value) => {
          const defaultBoldPattern = "**[123;;]answer[;;hint]**";
          const clozePatternSet = new Set(
            this.settingsManager.settings.clozePatterns
          );
          if (value) {
            clozePatternSet.add(defaultBoldPattern);
          } else {
            clozePatternSet.delete(defaultBoldPattern);
          }
          this.settingsManager.settings.clozePatterns = [...clozePatternSet];
          this.settingsManager.settings.convertBoldTextToClozes = value;
          await this.settingsManager.save();
          this.display();
        })
      );
    }).addSetting((setting) => {
      const convertCurlyBracketsToClozesEl = setting.setName(
        t("CONVERT_CURLY_BRACKETS_TO_CLOZES")
      );
      const elements = tHTML(
        "CONVERT_CURLY_BRACKETS_TO_CLOZES_DESC",
        {
          defaultPattern: "{{[123;;]answer[;;hint]}}"
        }
      );
      setting.descEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.descEl.append(elements[i2]);
      }
      convertCurlyBracketsToClozesEl.addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.convertCurlyBracketsToClozes).onChange(async (value) => {
          const defaultCurlyBracketsPattern = "{{[123;;]answer[;;hint]}}";
          const clozePatternSet = new Set(
            this.settingsManager.settings.clozePatterns
          );
          if (value) {
            clozePatternSet.add(defaultCurlyBracketsPattern);
          } else {
            clozePatternSet.delete(defaultCurlyBracketsPattern);
          }
          this.settingsManager.settings.clozePatterns = [...clozePatternSet];
          this.settingsManager.settings.convertCurlyBracketsToClozes = value;
          await this.settingsManager.save();
          this.display();
        })
      );
    }).addSetting((setting) => {
      const clozePatterns = setting.setName(t("CLOZE_PATTERNS"));
      const elements = tHTML("CLOZE_PATTERNS_DESC", {
        docsUrl: "https://stephenmwangi.com/obsidian-spaced-repetition/flashcards/cloze-cards/#cloze-types"
      });
      setting.descEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.descEl.append(elements[i2]);
      }
      clozePatterns.addTextArea(
        (text) => text.setPlaceholder(
          "Example:\n==[123;;]answer[;;hint]==\n**[123;;]answer[;;hint]**\n{{[123;;]answer[;;hint]}}"
        ).setValue(this.settingsManager.settings.clozePatterns.join("\n")).onChange((value) => {
          applySettingsUpdate(async () => {
            const defaultHightlightPattern = "==[123;;]answer[;;hint]==";
            const defaultBoldPattern = "**[123;;]answer[;;hint]**";
            const defaultCurlyBracketsPattern = "{{[123;;]answer[;;hint]}}";
            const clozePatternSet = new Set(
              value.split(/\n+/).map((v2) => v2.trim()).filter((v2) => v2)
            );
            if (clozePatternSet.has(defaultHightlightPattern)) {
              this.settingsManager.settings.convertHighlightsToClozes = true;
            } else {
              this.settingsManager.settings.convertHighlightsToClozes = false;
            }
            if (clozePatternSet.has(defaultBoldPattern)) {
              this.settingsManager.settings.convertBoldTextToClozes = true;
            } else {
              this.settingsManager.settings.convertBoldTextToClozes = false;
            }
            if (clozePatternSet.has(defaultCurlyBracketsPattern)) {
              this.settingsManager.settings.convertCurlyBracketsToClozes = true;
            } else {
              this.settingsManager.settings.convertCurlyBracketsToClozes = false;
            }
            this.settingsManager.settings.clozePatterns = [...clozePatternSet];
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("INLINE_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.singleLineCardSeparator = DEFAULT_SETTINGS.singleLineCardSeparator;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.singleLineCardSeparator).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.singleLineCardSeparator = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("INLINE_REVERSED_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.singleLineReversedCardSeparator = DEFAULT_SETTINGS.singleLineReversedCardSeparator;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.singleLineReversedCardSeparator).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.singleLineReversedCardSeparator = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("MULTILINE_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.multilineCardSeparator = DEFAULT_SETTINGS.multilineCardSeparator;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.multilineCardSeparator).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.multilineCardSeparator = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("MULTILINE_REVERSED_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.multilineReversedCardSeparator = DEFAULT_SETTINGS.multilineReversedCardSeparator;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.multilineReversedCardSeparator).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.multilineReversedCardSeparator = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("MULTILINE_CARDS_END_MARKER")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING"));
      if (didReadMultilineEndMarkerWarning) {
        setting.addExtraButton((button) => {
          button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
            this.settingsManager.settings.multilineCardEndMarker = DEFAULT_SETTINGS.multilineCardEndMarker;
            await this.settingsManager.save();
            this.display();
          });
        }).addText(
          (text) => text.setValue(this.settingsManager.settings.multilineCardEndMarker).onChange((value) => {
            applySettingsUpdate(async () => {
              this.settingsManager.settings.multilineCardEndMarker = value;
              await this.settingsManager.save();
            });
          })
        );
      } else {
        setting.addButton((button) => {
          button.setButtonText("Unlock Setting").setClass("mod-warning").onClick(() => {
            new ConfirmationModal(
              this.plugin.app,
              "Please read!",
              "Please only change this setting if you already added the characters denoting the end marker to all your multiline / cloze cards. Else you might loose your scheduling data!",
              "Unlocking setting.",
              () => {
                changeMultilineEndMarkerWarningState(true);
              }
            ).open();
          });
        });
      }
    });
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/main-page.tsx
var import_obsidian22 = require("obsidian");

// src/data/debug-logger.ts
var DebugLogger = class {
  constructor() {
    this.debugInfoLog = [];
    this.debugErrorLog = [];
    this.debugWarningLog = [];
  }
  /**
   * Logs a message of the specified type.
   */
  log(message, type) {
    switch (type) {
      case "info":
        this.debugInfoLog.push(message);
        break;
      case "error":
        this.debugErrorLog.push(message);
        break;
      case "warning":
        this.debugWarningLog.push(message);
        break;
    }
  }
  /**
   * Clears the log of all types.
   */
  emptyLogs() {
    this.debugInfoLog = [];
    this.debugErrorLog = [];
    this.debugWarningLog = [];
  }
  /**
   * Clears the log of the specified type.
   */
  emptyLog(type) {
    switch (type) {
      case "info":
        this.debugInfoLog = [];
        break;
      case "error":
        this.debugErrorLog = [];
        break;
      case "warning":
        this.debugWarningLog = [];
        break;
    }
  }
  getLog(type) {
    switch (type) {
      case "info":
        return this.debugInfoLog.join("\n");
      case "error":
        return this.debugErrorLog.join("\n");
      case "warning":
        return this.debugWarningLog.join("\n");
    }
  }
  getAllLogs() {
    return this.getLog("info") + "\n" + this.getLog("error") + "\n" + this.getLog("warning");
  }
};
var _DebugLoggerInstance = class _DebugLoggerInstance {
  static getInstance() {
    if (!_DebugLoggerInstance.instance) {
      _DebugLoggerInstance.instance = new DebugLogger();
    }
    return _DebugLoggerInstance.instance;
  }
};
_DebugLoggerInstance.instance = null;
var DebugLoggerInstance = _DebugLoggerInstance;

// src/parser.ts
var import_clozecraft = __toESM(require_dist());
var debugParser = false;
function setDebugParser(value) {
  debugParser = value;
}
var ParsedQuestionInfo = class {
  constructor(cardType, text, firstLineNum, lastLineNum) {
    this.cardType = cardType;
    this.text = text;
    this.firstLineNum = firstLineNum;
    this.lastLineNum = lastLineNum;
  }
  isQuestionLineNum(lineNum) {
    return lineNum >= this.firstLineNum && lineNum <= this.lastLineNum;
  }
};
function markerInsideCodeBlock(text, marker, markerIndex) {
  let goingBack = markerIndex - 1, goingForward = markerIndex + marker.length;
  let backTicksBefore = 0, backTicksAfter = 0;
  while (goingBack >= 0) {
    if (text[goingBack] === "`") backTicksBefore++;
    goingBack--;
  }
  while (goingForward < text.length) {
    if (text[goingForward] === "`") backTicksAfter++;
    goingForward++;
  }
  return backTicksBefore % 2 === 1 && backTicksAfter % 2 === 1;
}
function hasInlineMarker(text, marker) {
  if (marker.length === 0) return false;
  const markerIdx = text.indexOf(marker);
  if (markerIdx === -1) return false;
  return !markerInsideCodeBlock(text, marker, markerIdx);
}
function parse(text, options) {
  if (debugParser) {
    console.log("Text to parse:\n<<<" + text + ">>>");
  }
  const inlineSeparators = [
    { separator: options.singleLineCardSeparator, type: 0 /* SingleLineBasic */ },
    { separator: options.singleLineReversedCardSeparator, type: 1 /* SingleLineReversed */ }
  ];
  inlineSeparators.sort((a2, b2) => b2.separator.length - a2.separator.length);
  const cards = [];
  let cardText = "";
  let cardType = null;
  let firstLineNo = 0, lastLineNo;
  const clozecrafter = new import_clozecraft.ClozeCrafter(options.clozePatterns);
  const lines = text.replaceAll("\r\n", "\n").split("\n");
  for (let i2 = 0; i2 < lines.length; i2++) {
    const currentLine = lines[i2], currentTrimmed = lines[i2].trim();
    if (currentLine.startsWith("<!--") && !currentLine.startsWith("<!--SR:")) {
      while (i2 + 1 < lines.length && !currentLine.includes("-->")) i2++;
      i2++;
      continue;
    }
    const isEmptyLine = currentTrimmed.length === 0;
    const hasMultilineCardEndMarker = options.multilineCardEndMarker && currentTrimmed === options.multilineCardEndMarker;
    if (
      // We've probably reached the end of a card
      isEmptyLine && !options.multilineCardEndMarker || // Empty line & we're not picking up any card
      isEmptyLine && cardType === null || // We've reached the end of a multi line card &
      //  we're using custom end markers
      hasMultilineCardEndMarker
    ) {
      if (cardType) {
        lastLineNo = i2 - 1;
        cards.push(
          new ParsedQuestionInfo(cardType, cardText.trimEnd(), firstLineNo, lastLineNo)
        );
        cardType = null;
      }
      cardText = "";
      firstLineNo = i2 + 1;
      continue;
    }
    if (cardText.length > 0) {
      cardText += "\n";
    }
    cardText += currentLine.trimEnd();
    for (const { separator, type } of inlineSeparators) {
      if (hasInlineMarker(currentLine, separator)) {
        cardType = type;
        break;
      }
    }
    if (cardType === 0 /* SingleLineBasic */ || cardType === 1 /* SingleLineReversed */) {
      cardText = currentLine;
      firstLineNo = i2;
      if (i2 + 1 < lines.length && lines[i2 + 1].startsWith("<!--SR:")) {
        cardText += "\n" + lines[i2 + 1];
        i2++;
      } else if (i2 + 1 < lines.length && lines[i2 + 1].startsWith(SR_METADATA_CALLOUT)) {
        for (let j2 = i2 + 1; j2 < lines.length; j2++) {
          cardText += "\n" + lines[j2];
          i2++;
          if (lines[j2].includes("<!--SR:")) {
            break;
          }
        }
      }
      lastLineNo = i2;
      cards.push(new ParsedQuestionInfo(cardType, cardText, firstLineNo, lastLineNo));
      cardType = null;
      cardText = "";
    } else if (currentTrimmed === options.multilineCardSeparator) {
      if (cardText.length > 1) {
        cardType = 2 /* MultiLineBasic */;
      }
    } else if (currentTrimmed === options.multilineReversedCardSeparator) {
      if (cardText.length > 1) {
        cardType = 3 /* MultiLineReversed */;
      }
    } else if (currentLine.startsWith("```") || currentLine.startsWith("~~~")) {
      const codeBlockClose = currentLine.match(/`+|~+/)[0];
      while (i2 + 1 < lines.length && !lines[i2 + 1].startsWith(codeBlockClose)) {
        i2++;
        cardText += "\n" + lines[i2];
      }
      cardText += "\n" + codeBlockClose;
      i2++;
    } else if (cardType === null && clozecrafter.isClozeNote(currentLine)) {
      cardType = 4 /* Cloze */;
    }
  }
  if (cardType && cardText) {
    lastLineNo = lines.length - 1;
    cards.push(new ParsedQuestionInfo(cardType, cardText.trimEnd(), firstLineNo, lastLineNo));
  }
  if (debugParser) {
    console.log("Parsed cards:\n", cards);
  }
  return cards;
}

// src/ui/obsidian-ui-components/content-container/settings-page/main-page.tsx
var MainPage = class extends SettingsPage {
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, display, openPage, scrollListener) {
    super(
      pageContainerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      () => {
      },
      display,
      openPage,
      scrollListener
    );
    this.containerEl.addClass("sr-main-page");
    const mainSettingsGroup = new import_obsidian22.SettingGroup(this.containerEl).setHeading(
      t("SETTINGS_TAB_HEADING")
    );
    SettingsPageTypesArray.forEach((pageType2) => {
      if (pageType2 === "main-page") return;
      if (pageType2 === "statistics-page") return;
      mainSettingsGroup.addSetting((setting) => {
        setting.setName(getPageName(pageType2)).addButton((button) => {
          button.setIcon("chevron-right").onClick(() => {
            this.openPage(pageType2);
          });
          button.buttonEl.addClass("clickable-icon");
        });
        const iconEl = activeDocument.createElement("div");
        iconEl.addClass("sr-settings-page-title-icon");
        (0, import_obsidian22.setIcon)(iconEl, getPageIcon(pageType2));
        setting.nameEl.insertBefore(iconEl, setting.nameEl.firstChild);
        setting.nameEl.addClass("sr-settings-page-title");
        setting.settingEl.addClass("sr-settings-page-title-setting");
        setting.settingEl.addEventListener("click", () => {
          this.openPage(pageType2);
        });
      });
    });
    mainSettingsGroup.addSetting((setting) => {
      setting.setName(t("LANGUAGE_SETTINGS")).setDesc(t("LANGUAGE_SETTINGS_DESC")).addDropdown((dropdown) => {
        dropdown.addOption("-", t("DEFAULT_LOCALE_NAME"));
        LocaleManagerInstance.getInstance().getLocaleOptionsList().forEach((option) => {
          dropdown.addOption(option.language, option.languageName);
        });
        dropdown.setValue(this.settingsManager.settings.preferredLocale);
        dropdown.onChange(async (value) => {
          if (value === "-") {
            const loadedLocale = LocaleManagerInstance.getInstance().loadedLocale;
            LocaleManagerInstance.getInstance().currentLocale = loadedLocale;
          } else {
            LocaleManagerInstance.getInstance().currentLocale = value;
          }
          this.settingsManager.settings.preferredLocale = value;
          await this.plugin.dataManager.savePluginData();
          this.display();
        });
      });
    });
    new import_obsidian22.SettingGroup(this.containerEl).setHeading(t("INFO")).addSetting((setting) => {
      setting.setName(getPageName("statistics-page")).addButton((button) => {
        button.setIcon("chevron-right").onClick(() => {
          this.openPage("statistics-page");
        });
        button.buttonEl.addClass("clickable-icon");
      });
      const iconEl = activeDocument.createElement("div");
      iconEl.addClass("sr-settings-page-title-icon");
      (0, import_obsidian22.setIcon)(iconEl, getPageIcon("statistics-page"));
      setting.nameEl.insertBefore(iconEl, setting.nameEl.firstChild);
      setting.nameEl.addClass("sr-settings-page-title");
      setting.settingEl.addClass("sr-settings-page-title-setting");
      setting.settingEl.addEventListener("click", () => {
        this.openPage("statistics-page");
      });
    }).addSetting((setting) => {
      const elements = tHTML("CHECK_WIKI", {
        wikiUrl: "https://stephenmwangi.com/obsidian-spaced-repetition/"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      const elements = tHTML("CHECK_ROADMAP", {
        roadMapUrl: "https://github.com/users/st3v3nmw/projects/6"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      const elements = tHTML("CHECK_DEV_NEWS", {
        devNewsUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition/discussions/categories/development-news"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    });
    new import_obsidian22.SettingGroup(this.containerEl).setHeading(t("HELP") + " & " + t("GROUP_CONTRIBUTING")).addSetting((setting) => {
      const elements = tHTML("GITHUB_DISCUSSIONS", {
        discussionsUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition/discussions/"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      const elements = tHTML("GITHUB_ISSUES", {
        issuesUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition/issues/"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      const elements = tHTML("GITHUB_SOURCE_CODE", {
        githubProjectUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      const elements = tHTML("CODE_CONTRIBUTION_INFO", {
        codeContributionUrl: "https://stephenmwangi.com/obsidian-spaced-repetition/contributing/#code"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      const elements = tHTML("TRANSLATION_CONTRIBUTION_INFO", {
        translationContributionUrl: "https://stephenmwangi.com/obsidian-spaced-repetition/contributing/#translating"
      });
      setting.infoEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.infoEl.append(elements[i2]);
      }
    });
    new import_obsidian22.SettingGroup(this.containerEl).setHeading(t("LOGGING")).addSetting((setting) => {
      setting.setName(t("DISPLAY_SCHEDULING_DEBUG_INFO")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showSchedulingDebugMessages).onChange(async (value) => {
          this.settingsManager.settings.showSchedulingDebugMessages = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("DISPLAY_PARSER_DEBUG_INFO")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showParserDebugMessages).onChange(async (value) => {
          this.settingsManager.settings.showParserDebugMessages = value;
          setDebugParser(this.settingsManager.settings.showParserDebugMessages);
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("DEBUG_LOG")).addTextArea(
        (text) => text.setValue(DebugLoggerInstance.getInstance().getLog("info"))
      ).addExtraButton((button) => {
        button.setIcon("copy").setTooltip(t("COPY")).onClick(async () => {
          await navigator.clipboard.writeText(
            DebugLoggerInstance.getInstance().getLog("info")
          );
        });
      });
    });
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/notes-page.tsx
var import_obsidian23 = require("obsidian");
var NotesPage = class extends SettingsPage {
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, applySettingsUpdate, display, openPage, scrollListener) {
    super(
      pageContainerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      applySettingsUpdate,
      display,
      openPage,
      scrollListener
    );
    new import_obsidian23.SettingGroup(this.containerEl).setHeading(t("GROUP_TAGS_FOLDERS")).addSetting((setting) => {
      setting.setName(t("TAGS_TO_REVIEW")).setDesc(t("TAGS_TO_REVIEW_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.tagsToReview.join(" ")).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.tagsToReview = value.split(/\s+/);
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("NOTE_TAGS_TO_IGNORE")).setDesc(t("NOTE_TAGS_TO_IGNORE_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.noteTagsToIgnore.join(" ")).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.noteTagsToIgnore = value.split(/\s+/).filter((v2) => v2);
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("FOLDERS_TO_IGNORE")).setDesc(t("FOLDERS_TO_IGNORE_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.noteFoldersToIgnore.join("\n")).onChange((value) => {
          this.applySettingsUpdate(async () => {
            this.settingsManager.settings.noteFoldersToIgnore = value.split(/\n+/).map((v2) => v2.trim()).filter((v2) => v2);
            await this.settingsManager.save();
          });
        })
      );
    });
    new import_obsidian23.SettingGroup(this.containerEl).setHeading(t("NOTES_REVIEW_QUEUE")).addSetting((setting) => {
      setting.setName(t("DATE_FORMAT_FOR_NOTE_REVIEW_QUEUE")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.preferredDateFormatForNoteReviewQueue = DEFAULT_SETTINGS.preferredDateFormatForNoteReviewQueue;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(
          this.settingsManager.settings.preferredDateFormatForNoteReviewQueue
        ).onChange((value) => {
          this.applySettingsUpdate(async () => {
            this.settingsManager.settings.preferredDateFormatForNoteReviewQueue = value;
            await this.settingsManager.save();
          });
        })
      );
      const elements = tHTML(
        "DATE_FORMAT_FOR_NOTE_REVIEW_QUEUE_DESC",
        {
          docsUrl: "https://momentjs.com/docs/#/displaying/format/"
        }
      );
      setting.descEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        setting.descEl.append(elements[i2]);
      }
    }).addSetting((setting) => {
      setting.setName(t("AUTO_NEXT_NOTE")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.autoNextNote).onChange(async (value) => {
          this.settingsManager.settings.autoNextNote = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("OPEN_RANDOM_NOTE")).setDesc(t("OPEN_RANDOM_NOTE_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.openRandomNote).onChange(async (value) => {
          this.settingsManager.settings.openRandomNote = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_PANE_ON_STARTUP")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.enableNoteReviewPaneOnStartup).onChange(async (value) => {
          this.settingsManager.settings.enableNoteReviewPaneOnStartup = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("MAX_N_DAYS_REVIEW_QUEUE")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.maxNDaysNotesReviewQueue = DEFAULT_SETTINGS.maxNDaysNotesReviewQueue;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(
          this.settingsManager.settings.maxNDaysNotesReviewQueue.toString()
        ).onChange((value) => {
          applySettingsUpdate(async () => {
            const numValue = Number.parseInt(value);
            if (!isNaN(numValue)) {
              if (numValue < 1) {
                new import_obsidian23.Notice(t("MIN_ONE_DAY"));
                text.setValue(
                  this.settingsManager.settings.maxNDaysNotesReviewQueue.toString()
                );
                return;
              }
              this.settingsManager.settings.maxNDaysNotesReviewQueue = numValue;
              await this.settingsManager.save();
            } else {
              new import_obsidian23.Notice(t("VALID_NUMBER_WARNING"));
            }
          });
        })
      );
    });
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/scheduling-page.tsx
var import_obsidian24 = require("obsidian");
var SchedulingPage = class extends SettingsPage {
  async setAlgorithm(algorithm) {
    this.settingsManager.settings.algorithm = algorithm;
    await this.settingsManager.save();
    this.dataManager.setupDataStoreAndAlgorithmInstances(this.settingsManager.settings);
    this.display();
  }
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, applySettingsUpdate, display, openPage, scrollListener) {
    super(
      pageContainerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      applySettingsUpdate,
      display,
      openPage,
      scrollListener
    );
    new import_obsidian24.SettingGroup(this.containerEl).setHeading(t("REVIEW_REMINDERS")).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDERS")).setDesc(t("REVIEW_REMINDERS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.enableReviewReminders).onChange(async (value) => {
          this.settingsManager.settings.enableReviewReminders = value;
          await this.settingsManager.save();
          this.plugin.reminderManager.restartReviewReminders();
          this.display();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_CHECK_ON_STARTUP")).setDesc(t("REVIEW_REMINDER_CHECK_ON_STARTUP_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.reviewReminderCheckOnStartup).setDisabled(!this.settingsManager.settings.enableReviewReminders).onChange(async (value) => {
          this.settingsManager.settings.reviewReminderCheckOnStartup = value;
          await this.settingsManager.save();
          this.plugin.reminderManager.restartReviewReminders();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_INTERVAL")).setDesc(t("REVIEW_REMINDER_INTERVAL_DESC")).addText((text) => {
        text.setValue(
          this.settingsManager.settings.reviewReminderIntervalMinutes.toString()
        );
        text.inputEl.type = "number";
        text.inputEl.min = "1";
        text.inputEl.max = "1440";
        text.inputEl.step = "1";
        text.setDisabled(!this.settingsManager.settings.enableReviewReminders);
        const commitIntervalValue = (value) => {
          this.applySettingsUpdate(async () => {
            const parsedValue = Number.parseInt(value);
            if (Number.isNaN(parsedValue) || parsedValue < 1 || parsedValue > 1440) {
              new import_obsidian24.Notice(t("REVIEW_REMINDER_INTERVAL_MIN_WARNING"));
              text.setValue(
                this.settingsManager.settings.reviewReminderIntervalMinutes.toString()
              );
              return;
            }
            this.settingsManager.settings.reviewReminderIntervalMinutes = parsedValue;
            await this.settingsManager.save();
            this.plugin.reminderManager.restartReviewReminders();
          });
        };
        text.inputEl.addEventListener("blur", () => {
          commitIntervalValue(text.getValue());
        });
        text.inputEl.addEventListener("keydown", (event) => {
          if (event.key === "Enter") {
            commitIntervalValue(text.getValue());
          }
        });
      });
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_MESSAGE")).setDesc(t("REVIEW_REMINDER_MESSAGE_DESC")).addTextArea(
        (text) => text.setValue(this.settingsManager.settings.reviewReminderMessage).setDisabled(!this.settingsManager.settings.enableReviewReminders).onChange((value) => {
          this.applySettingsUpdate(async () => {
            this.settingsManager.settings.reviewReminderMessage = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_AUTO_OPEN")).setDesc(t("REVIEW_REMINDER_AUTO_OPEN_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.reviewReminderAutoOpen).setDisabled(!this.settingsManager.settings.enableReviewReminders).onChange(async (value) => {
          this.settingsManager.settings.reviewReminderAutoOpen = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_SHOW_NOTICE")).setDesc(t("REVIEW_REMINDER_SHOW_NOTICE_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.reviewReminderShowNotice).setDisabled(!this.settingsManager.settings.enableReviewReminders).onChange(async (value) => {
          this.settingsManager.settings.reviewReminderShowNotice = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_PLAY_SOUND")).setDesc(t("REVIEW_REMINDER_PLAY_SOUND_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.reviewReminderPlaySound).setDisabled(!this.settingsManager.settings.enableReviewReminders).onChange(async (value) => {
          this.settingsManager.settings.reviewReminderPlaySound = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_REMINDER_BOUNCE_DOCK")).setDesc(t("REVIEW_REMINDER_BOUNCE_DOCK_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.reviewReminderBounceDock).setDisabled(!this.settingsManager.settings.enableReviewReminders).onChange(async (value) => {
          this.settingsManager.settings.reviewReminderBounceDock = value;
          await this.settingsManager.save();
        })
      );
    });
    const algorithmGroup = new import_obsidian24.SettingGroup(this.containerEl).setHeading(t("ALGORITHM"));
    algorithmGroup.addSetting((setting) => {
      const algoSettingEl = setting.setName(t("ALGORITHM")).setDesc("").addDropdown(
        (dropdown) => dropdown.addOptions({
          "SM-2-OSR": t("SM2_OSR_VARIANT"),
          FSRS: "FSRS"
        }).setValue(this.settingsManager.settings.algorithm).onChange(async (value) => {
          const selectedAlgorithm = value;
          const currentAlgorithm = this.settingsManager.settings.algorithm;
          if (selectedAlgorithm === currentAlgorithm) {
            return;
          }
          if (currentAlgorithm === "SM-2-OSR" /* SM_2_OSR */ && selectedAlgorithm === "FSRS" /* FSRS */) {
            dropdown.setValue(currentAlgorithm);
            new ConfirmationModal(
              this.plugin.app,
              t("SWITCH_TO_FSRS_ALGORITHM"),
              t("CONFIRM_FSRS_ALGORITHM_SWITCH"),
              void 0,
              async () => {
                await this.setAlgorithm(selectedAlgorithm);
              }
            ).open();
            return;
          }
          await this.setAlgorithm(selectedAlgorithm);
        })
      );
      const elements = tHTML("CHECK_ALGORITHM_WIKI", {
        algoUrl: "https://stephenmwangi.com/obsidian-spaced-repetition/algorithms/"
      });
      algoSettingEl.descEl.empty();
      for (let i2 = 0; i2 < elements.length; i2++) {
        algoSettingEl.descEl.append(elements[i2]);
      }
    });
    algorithmGroup.addSetting((setting) => {
      setting.setName("Flashcard algorithm scope").setDesc(
        "The selected algorithm applies to flashcards and clozes only. Whole-note review continues to use the existing OSR scheduler."
      );
    });
    if (this.settingsManager.settings.algorithm === "FSRS" /* FSRS */) {
      algorithmGroup.addSetting((setting) => {
        setting.setName("FSRS desired retention").setDesc("Target recall probability used by FSRS for flashcard scheduling.").addExtraButton((button) => {
          button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
            this.settingsManager.settings.fsrsDesiredRetention = DEFAULT_SETTINGS.fsrsDesiredRetention;
            await this.settingsManager.save();
            this.display();
          });
        }).addText(
          (text) => text.setValue(this.settingsManager.settings.fsrsDesiredRetention.toString()).onChange((value) => {
            applySettingsUpdate(async () => {
              const numValue = Number.parseFloat(value);
              if (Number.isNaN(numValue) || numValue <= 0 || numValue > 1) {
                new import_obsidian24.Notice(
                  "FSRS desired retention must be between 0 and 1."
                );
                text.setValue(
                  this.settingsManager.settings.fsrsDesiredRetention.toString()
                );
                return;
              }
              this.settingsManager.settings.fsrsDesiredRetention = numValue;
              await this.settingsManager.save();
            });
          })
        );
      });
    }
    if (this.settingsManager.settings.algorithm === "SM-2-OSR" /* SM_2_OSR */) {
      algorithmGroup.addSetting((setting) => {
        setting.setName(t("BASE_EASE")).setDesc(t("BASE_EASE_DESC")).addExtraButton((button) => {
          button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
            this.settingsManager.settings.baseEase = DEFAULT_SETTINGS.baseEase;
            await this.settingsManager.save();
            this.display();
          });
        }).addText(
          (text) => text.setValue(this.settingsManager.settings.baseEase.toString()).onChange((value) => {
            applySettingsUpdate(async () => {
              const numValue = Number.parseInt(value);
              if (!isNaN(numValue)) {
                if (numValue < 130) {
                  new import_obsidian24.Notice(t("BASE_EASE_MIN_WARNING"));
                  text.setValue(
                    this.settingsManager.settings.baseEase.toString()
                  );
                  return;
                }
                this.settingsManager.settings.baseEase = numValue;
                await this.settingsManager.save();
              } else {
                new import_obsidian24.Notice(t("VALID_NUMBER_WARNING"));
              }
            });
          })
        );
      }).addSetting((setting) => {
        setting.setName(t("MAX_LINK_CONTRIB")).setDesc(t("MAX_LINK_CONTRIB_DESC")).addExtraButton((button) => {
          button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
            this.settingsManager.settings.maxLinkFactor = DEFAULT_SETTINGS.maxLinkFactor;
            await this.settingsManager.save();
            this.display();
          });
        }).addSlider(
          (slider) => slider.setLimits(0, 100, 1).setValue(this.settingsManager.settings.maxLinkFactor * 100).setDynamicTooltip().onChange(async (value) => {
            this.settingsManager.settings.maxLinkFactor = value / 100;
            await this.settingsManager.save();
          })
        );
      }).addSetting((setting) => {
        setting.setName(t("LAPSE_INTERVAL_CHANGE")).setDesc(t("LAPSE_INTERVAL_CHANGE_DESC")).addExtraButton((button) => {
          button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
            this.settingsManager.settings.lapsesIntervalChange = DEFAULT_SETTINGS.lapsesIntervalChange;
            await this.settingsManager.save();
            this.display();
          });
        }).addSlider(
          (slider) => slider.setLimits(1, 99, 1).setValue(this.settingsManager.settings.lapsesIntervalChange * 100).setDynamicTooltip().onChange(async (value) => {
            this.settingsManager.settings.lapsesIntervalChange = value / 100;
            await this.settingsManager.save();
          })
        );
      }).addSetting((setting) => {
        setting.setName(t("EASY_BONUS")).setDesc(t("EASY_BONUS_DESC")).addExtraButton((button) => {
          button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
            this.settingsManager.settings.easyBonus = DEFAULT_SETTINGS.easyBonus;
            await this.settingsManager.save();
            this.display();
          });
        }).addText(
          (text) => text.setValue(
            (this.settingsManager.settings.easyBonus * 100).toString()
          ).onChange((value) => {
            applySettingsUpdate(async () => {
              const numValue = Number.parseInt(value) / 100;
              if (!isNaN(numValue)) {
                if (numValue < 1) {
                  new import_obsidian24.Notice(t("EASY_BONUS_MIN_WARNING"));
                  text.setValue(
                    (this.settingsManager.settings.easyBonus * 100).toString()
                  );
                  return;
                }
                this.settingsManager.settings.easyBonus = numValue;
                await this.settingsManager.save();
              } else {
                new import_obsidian24.Notice(t("VALID_NUMBER_WARNING"));
              }
            });
          })
        );
      }).addSetting((setting) => {
        setting.setName(t("LOAD_BALANCE")).setDesc(t("LOAD_BALANCE_DESC")).addToggle(
          (toggle) => toggle.setValue(this.settingsManager.settings.loadBalance).onChange(async (value) => {
            this.settingsManager.settings.loadBalance = value;
            await this.settingsManager.save();
          })
        );
      });
    }
    algorithmGroup.addSetting((setting) => {
      setting.setName(t("MAX_INTERVAL")).setDesc(t("MAX_INTERVAL_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.maximumInterval = DEFAULT_SETTINGS.maximumInterval;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.maximumInterval.toString()).onChange((value) => {
          applySettingsUpdate(async () => {
            const numValue = Number.parseInt(value);
            if (!isNaN(numValue)) {
              if (numValue < 1) {
                new import_obsidian24.Notice(t("MAX_INTERVAL_MIN_WARNING"));
                text.setValue(
                  this.settingsManager.settings.maximumInterval.toString()
                );
                return;
              }
              this.settingsManager.settings.maximumInterval = numValue;
              await this.settingsManager.save();
            } else {
              new import_obsidian24.Notice(t("VALID_NUMBER_WARNING"));
            }
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("START_OF_DAY")).setDesc(t("START_OF_DAY_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.startOfDay = DEFAULT_SETTINGS.startOfDay;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.startOfDay).onChange((value) => {
          applySettingsUpdate(async () => {
            const dayBoundary = DateUtil.strToDayBoundary(value);
            if (dayBoundary === null) {
              new import_obsidian24.Notice(t("INVALID_START_OF_DAY_WARNING"));
              return;
            } else {
              this.settingsManager.settings.startOfDay = value;
              await this.settingsManager.save();
              globalDateProvider.setDayBoundary(dayBoundary);
            }
          });
        })
      );
    });
  }
};

// node_modules/.pnpm/@kurkle+color@0.3.4/node_modules/@kurkle/color/dist/color.esm.js
function round(v2) {
  return v2 + 0.5 | 0;
}
var lim = (v2, l2, h3) => Math.max(Math.min(v2, h3), l2);
function p2b(v2) {
  return lim(round(v2 * 2.55), 0, 255);
}
function n2b(v2) {
  return lim(round(v2 * 255), 0, 255);
}
function b2n(v2) {
  return lim(round(v2 / 2.55) / 100, 0, 1);
}
function n2p(v2) {
  return lim(round(v2 * 100), 0, 100);
}
var map$1 = { 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15 };
var hex = [..."0123456789ABCDEF"];
var h1 = (b2) => hex[b2 & 15];
var h2 = (b2) => hex[(b2 & 240) >> 4] + hex[b2 & 15];
var eq = (b2) => (b2 & 240) >> 4 === (b2 & 15);
var isShort = (v2) => eq(v2.r) && eq(v2.g) && eq(v2.b) && eq(v2.a);
function hexParse(str) {
  var len = str.length;
  var ret;
  if (str[0] === "#") {
    if (len === 4 || len === 5) {
      ret = {
        r: 255 & map$1[str[1]] * 17,
        g: 255 & map$1[str[2]] * 17,
        b: 255 & map$1[str[3]] * 17,
        a: len === 5 ? map$1[str[4]] * 17 : 255
      };
    } else if (len === 7 || len === 9) {
      ret = {
        r: map$1[str[1]] << 4 | map$1[str[2]],
        g: map$1[str[3]] << 4 | map$1[str[4]],
        b: map$1[str[5]] << 4 | map$1[str[6]],
        a: len === 9 ? map$1[str[7]] << 4 | map$1[str[8]] : 255
      };
    }
  }
  return ret;
}
var alpha = (a2, f2) => a2 < 255 ? f2(a2) : "";
function hexString(v2) {
  var f2 = isShort(v2) ? h1 : h2;
  return v2 ? "#" + f2(v2.r) + f2(v2.g) + f2(v2.b) + alpha(v2.a, f2) : void 0;
}
var HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;
function hsl2rgbn(h3, s2, l2) {
  const a2 = s2 * Math.min(l2, 1 - l2);
  const f2 = (n2, k = (n2 + h3 / 30) % 12) => l2 - a2 * Math.max(Math.min(k - 3, 9 - k, 1), -1);
  return [f2(0), f2(8), f2(4)];
}
function hsv2rgbn(h3, s2, v2) {
  const f2 = (n2, k = (n2 + h3 / 60) % 6) => v2 - v2 * s2 * Math.max(Math.min(k, 4 - k, 1), 0);
  return [f2(5), f2(3), f2(1)];
}
function hwb2rgbn(h3, w2, b2) {
  const rgb = hsl2rgbn(h3, 1, 0.5);
  let i2;
  if (w2 + b2 > 1) {
    i2 = 1 / (w2 + b2);
    w2 *= i2;
    b2 *= i2;
  }
  for (i2 = 0; i2 < 3; i2++) {
    rgb[i2] *= 1 - w2 - b2;
    rgb[i2] += w2;
  }
  return rgb;
}
function hueValue(r2, g2, b2, d2, max) {
  if (r2 === max) {
    return (g2 - b2) / d2 + (g2 < b2 ? 6 : 0);
  }
  if (g2 === max) {
    return (b2 - r2) / d2 + 2;
  }
  return (r2 - g2) / d2 + 4;
}
function rgb2hsl(v2) {
  const range2 = 255;
  const r2 = v2.r / range2;
  const g2 = v2.g / range2;
  const b2 = v2.b / range2;
  const max = Math.max(r2, g2, b2);
  const min = Math.min(r2, g2, b2);
  const l2 = (max + min) / 2;
  let h3, s2, d2;
  if (max !== min) {
    d2 = max - min;
    s2 = l2 > 0.5 ? d2 / (2 - max - min) : d2 / (max + min);
    h3 = hueValue(r2, g2, b2, d2, max);
    h3 = h3 * 60 + 0.5;
  }
  return [h3 | 0, s2 || 0, l2];
}
function calln(f2, a2, b2, c2) {
  return (Array.isArray(a2) ? f2(a2[0], a2[1], a2[2]) : f2(a2, b2, c2)).map(n2b);
}
function hsl2rgb(h3, s2, l2) {
  return calln(hsl2rgbn, h3, s2, l2);
}
function hwb2rgb(h3, w2, b2) {
  return calln(hwb2rgbn, h3, w2, b2);
}
function hsv2rgb(h3, s2, v2) {
  return calln(hsv2rgbn, h3, s2, v2);
}
function hue(h3) {
  return (h3 % 360 + 360) % 360;
}
function hueParse(str) {
  const m2 = HUE_RE.exec(str);
  let a2 = 255;
  let v2;
  if (!m2) {
    return;
  }
  if (m2[5] !== v2) {
    a2 = m2[6] ? p2b(+m2[5]) : n2b(+m2[5]);
  }
  const h3 = hue(+m2[2]);
  const p1 = +m2[3] / 100;
  const p2 = +m2[4] / 100;
  if (m2[1] === "hwb") {
    v2 = hwb2rgb(h3, p1, p2);
  } else if (m2[1] === "hsv") {
    v2 = hsv2rgb(h3, p1, p2);
  } else {
    v2 = hsl2rgb(h3, p1, p2);
  }
  return {
    r: v2[0],
    g: v2[1],
    b: v2[2],
    a: a2
  };
}
function rotate(v2, deg) {
  var h3 = rgb2hsl(v2);
  h3[0] = hue(h3[0] + deg);
  h3 = hsl2rgb(h3);
  v2.r = h3[0];
  v2.g = h3[1];
  v2.b = h3[2];
}
function hslString(v2) {
  if (!v2) {
    return;
  }
  const a2 = rgb2hsl(v2);
  const h3 = a2[0];
  const s2 = n2p(a2[1]);
  const l2 = n2p(a2[2]);
  return v2.a < 255 ? `hsla(${h3}, ${s2}%, ${l2}%, ${b2n(v2.a)})` : `hsl(${h3}, ${s2}%, ${l2}%)`;
}
var map = {
  x: "dark",
  Z: "light",
  Y: "re",
  X: "blu",
  W: "gr",
  V: "medium",
  U: "slate",
  A: "ee",
  T: "ol",
  S: "or",
  B: "ra",
  C: "lateg",
  D: "ights",
  R: "in",
  Q: "turquois",
  E: "hi",
  P: "ro",
  O: "al",
  N: "le",
  M: "de",
  L: "yello",
  F: "en",
  K: "ch",
  G: "arks",
  H: "ea",
  I: "ightg",
  J: "wh"
};
var names$1 = {
  OiceXe: "f0f8ff",
  antiquewEte: "faebd7",
  aqua: "ffff",
  aquamarRe: "7fffd4",
  azuY: "f0ffff",
  beige: "f5f5dc",
  bisque: "ffe4c4",
  black: "0",
  blanKedOmond: "ffebcd",
  Xe: "ff",
  XeviTet: "8a2be2",
  bPwn: "a52a2a",
  burlywood: "deb887",
  caMtXe: "5f9ea0",
  KartYuse: "7fff00",
  KocTate: "d2691e",
  cSO: "ff7f50",
  cSnflowerXe: "6495ed",
  cSnsilk: "fff8dc",
  crimson: "dc143c",
  cyan: "ffff",
  xXe: "8b",
  xcyan: "8b8b",
  xgTMnPd: "b8860b",
  xWay: "a9a9a9",
  xgYF: "6400",
  xgYy: "a9a9a9",
  xkhaki: "bdb76b",
  xmagFta: "8b008b",
  xTivegYF: "556b2f",
  xSange: "ff8c00",
  xScEd: "9932cc",
  xYd: "8b0000",
  xsOmon: "e9967a",
  xsHgYF: "8fbc8f",
  xUXe: "483d8b",
  xUWay: "2f4f4f",
  xUgYy: "2f4f4f",
  xQe: "ced1",
  xviTet: "9400d3",
  dAppRk: "ff1493",
  dApskyXe: "bfff",
  dimWay: "696969",
  dimgYy: "696969",
  dodgerXe: "1e90ff",
  fiYbrick: "b22222",
  flSOwEte: "fffaf0",
  foYstWAn: "228b22",
  fuKsia: "ff00ff",
  gaRsbSo: "dcdcdc",
  ghostwEte: "f8f8ff",
  gTd: "ffd700",
  gTMnPd: "daa520",
  Way: "808080",
  gYF: "8000",
  gYFLw: "adff2f",
  gYy: "808080",
  honeyMw: "f0fff0",
  hotpRk: "ff69b4",
  RdianYd: "cd5c5c",
  Rdigo: "4b0082",
  ivSy: "fffff0",
  khaki: "f0e68c",
  lavFMr: "e6e6fa",
  lavFMrXsh: "fff0f5",
  lawngYF: "7cfc00",
  NmoncEffon: "fffacd",
  ZXe: "add8e6",
  ZcSO: "f08080",
  Zcyan: "e0ffff",
  ZgTMnPdLw: "fafad2",
  ZWay: "d3d3d3",
  ZgYF: "90ee90",
  ZgYy: "d3d3d3",
  ZpRk: "ffb6c1",
  ZsOmon: "ffa07a",
  ZsHgYF: "20b2aa",
  ZskyXe: "87cefa",
  ZUWay: "778899",
  ZUgYy: "778899",
  ZstAlXe: "b0c4de",
  ZLw: "ffffe0",
  lime: "ff00",
  limegYF: "32cd32",
  lRF: "faf0e6",
  magFta: "ff00ff",
  maPon: "800000",
  VaquamarRe: "66cdaa",
  VXe: "cd",
  VScEd: "ba55d3",
  VpurpN: "9370db",
  VsHgYF: "3cb371",
  VUXe: "7b68ee",
  VsprRggYF: "fa9a",
  VQe: "48d1cc",
  VviTetYd: "c71585",
  midnightXe: "191970",
  mRtcYam: "f5fffa",
  mistyPse: "ffe4e1",
  moccasR: "ffe4b5",
  navajowEte: "ffdead",
  navy: "80",
  Tdlace: "fdf5e6",
  Tive: "808000",
  TivedBb: "6b8e23",
  Sange: "ffa500",
  SangeYd: "ff4500",
  ScEd: "da70d6",
  pOegTMnPd: "eee8aa",
  pOegYF: "98fb98",
  pOeQe: "afeeee",
  pOeviTetYd: "db7093",
  papayawEp: "ffefd5",
  pHKpuff: "ffdab9",
  peru: "cd853f",
  pRk: "ffc0cb",
  plum: "dda0dd",
  powMrXe: "b0e0e6",
  purpN: "800080",
  YbeccapurpN: "663399",
  Yd: "ff0000",
  Psybrown: "bc8f8f",
  PyOXe: "4169e1",
  saddNbPwn: "8b4513",
  sOmon: "fa8072",
  sandybPwn: "f4a460",
  sHgYF: "2e8b57",
  sHshell: "fff5ee",
  siFna: "a0522d",
  silver: "c0c0c0",
  skyXe: "87ceeb",
  UXe: "6a5acd",
  UWay: "708090",
  UgYy: "708090",
  snow: "fffafa",
  sprRggYF: "ff7f",
  stAlXe: "4682b4",
  tan: "d2b48c",
  teO: "8080",
  tEstN: "d8bfd8",
  tomato: "ff6347",
  Qe: "40e0d0",
  viTet: "ee82ee",
  JHt: "f5deb3",
  wEte: "ffffff",
  wEtesmoke: "f5f5f5",
  Lw: "ffff00",
  LwgYF: "9acd32"
};
function unpack() {
  const unpacked = {};
  const keys = Object.keys(names$1);
  const tkeys = Object.keys(map);
  let i2, j2, k, ok, nk;
  for (i2 = 0; i2 < keys.length; i2++) {
    ok = nk = keys[i2];
    for (j2 = 0; j2 < tkeys.length; j2++) {
      k = tkeys[j2];
      nk = nk.replace(k, map[k]);
    }
    k = parseInt(names$1[ok], 16);
    unpacked[nk] = [k >> 16 & 255, k >> 8 & 255, k & 255];
  }
  return unpacked;
}
var names;
function nameParse(str) {
  if (!names) {
    names = unpack();
    names.transparent = [0, 0, 0, 0];
  }
  const a2 = names[str.toLowerCase()];
  return a2 && {
    r: a2[0],
    g: a2[1],
    b: a2[2],
    a: a2.length === 4 ? a2[3] : 255
  };
}
var RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;
function rgbParse(str) {
  const m2 = RGB_RE.exec(str);
  let a2 = 255;
  let r2, g2, b2;
  if (!m2) {
    return;
  }
  if (m2[7] !== r2) {
    const v2 = +m2[7];
    a2 = m2[8] ? p2b(v2) : lim(v2 * 255, 0, 255);
  }
  r2 = +m2[1];
  g2 = +m2[3];
  b2 = +m2[5];
  r2 = 255 & (m2[2] ? p2b(r2) : lim(r2, 0, 255));
  g2 = 255 & (m2[4] ? p2b(g2) : lim(g2, 0, 255));
  b2 = 255 & (m2[6] ? p2b(b2) : lim(b2, 0, 255));
  return {
    r: r2,
    g: g2,
    b: b2,
    a: a2
  };
}
function rgbString(v2) {
  return v2 && (v2.a < 255 ? `rgba(${v2.r}, ${v2.g}, ${v2.b}, ${b2n(v2.a)})` : `rgb(${v2.r}, ${v2.g}, ${v2.b})`);
}
var to = (v2) => v2 <= 31308e-7 ? v2 * 12.92 : Math.pow(v2, 1 / 2.4) * 1.055 - 0.055;
var from = (v2) => v2 <= 0.04045 ? v2 / 12.92 : Math.pow((v2 + 0.055) / 1.055, 2.4);
function interpolate(rgb1, rgb2, t3) {
  const r2 = from(b2n(rgb1.r));
  const g2 = from(b2n(rgb1.g));
  const b2 = from(b2n(rgb1.b));
  return {
    r: n2b(to(r2 + t3 * (from(b2n(rgb2.r)) - r2))),
    g: n2b(to(g2 + t3 * (from(b2n(rgb2.g)) - g2))),
    b: n2b(to(b2 + t3 * (from(b2n(rgb2.b)) - b2))),
    a: rgb1.a + t3 * (rgb2.a - rgb1.a)
  };
}
function modHSL(v2, i2, ratio) {
  if (v2) {
    let tmp = rgb2hsl(v2);
    tmp[i2] = Math.max(0, Math.min(tmp[i2] + tmp[i2] * ratio, i2 === 0 ? 360 : 1));
    tmp = hsl2rgb(tmp);
    v2.r = tmp[0];
    v2.g = tmp[1];
    v2.b = tmp[2];
  }
}
function clone(v2, proto) {
  return v2 ? Object.assign(proto || {}, v2) : v2;
}
function fromObject(input) {
  var v2 = { r: 0, g: 0, b: 0, a: 255 };
  if (Array.isArray(input)) {
    if (input.length >= 3) {
      v2 = { r: input[0], g: input[1], b: input[2], a: 255 };
      if (input.length > 3) {
        v2.a = n2b(input[3]);
      }
    }
  } else {
    v2 = clone(input, { r: 0, g: 0, b: 0, a: 1 });
    v2.a = n2b(v2.a);
  }
  return v2;
}
function functionParse(str) {
  if (str.charAt(0) === "r") {
    return rgbParse(str);
  }
  return hueParse(str);
}
var Color = class _Color {
  constructor(input) {
    if (input instanceof _Color) {
      return input;
    }
    const type = typeof input;
    let v2;
    if (type === "object") {
      v2 = fromObject(input);
    } else if (type === "string") {
      v2 = hexParse(input) || nameParse(input) || functionParse(input);
    }
    this._rgb = v2;
    this._valid = !!v2;
  }
  get valid() {
    return this._valid;
  }
  get rgb() {
    var v2 = clone(this._rgb);
    if (v2) {
      v2.a = b2n(v2.a);
    }
    return v2;
  }
  set rgb(obj) {
    this._rgb = fromObject(obj);
  }
  rgbString() {
    return this._valid ? rgbString(this._rgb) : void 0;
  }
  hexString() {
    return this._valid ? hexString(this._rgb) : void 0;
  }
  hslString() {
    return this._valid ? hslString(this._rgb) : void 0;
  }
  mix(color2, weight) {
    if (color2) {
      const c1 = this.rgb;
      const c2 = color2.rgb;
      let w2;
      const p2 = weight === w2 ? 0.5 : weight;
      const w3 = 2 * p2 - 1;
      const a2 = c1.a - c2.a;
      const w1 = ((w3 * a2 === -1 ? w3 : (w3 + a2) / (1 + w3 * a2)) + 1) / 2;
      w2 = 1 - w1;
      c1.r = 255 & w1 * c1.r + w2 * c2.r + 0.5;
      c1.g = 255 & w1 * c1.g + w2 * c2.g + 0.5;
      c1.b = 255 & w1 * c1.b + w2 * c2.b + 0.5;
      c1.a = p2 * c1.a + (1 - p2) * c2.a;
      this.rgb = c1;
    }
    return this;
  }
  interpolate(color2, t3) {
    if (color2) {
      this._rgb = interpolate(this._rgb, color2._rgb, t3);
    }
    return this;
  }
  clone() {
    return new _Color(this.rgb);
  }
  alpha(a2) {
    this._rgb.a = n2b(a2);
    return this;
  }
  clearer(ratio) {
    const rgb = this._rgb;
    rgb.a *= 1 - ratio;
    return this;
  }
  greyscale() {
    const rgb = this._rgb;
    const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);
    rgb.r = rgb.g = rgb.b = val;
    return this;
  }
  opaquer(ratio) {
    const rgb = this._rgb;
    rgb.a *= 1 + ratio;
    return this;
  }
  negate() {
    const v2 = this._rgb;
    v2.r = 255 - v2.r;
    v2.g = 255 - v2.g;
    v2.b = 255 - v2.b;
    return this;
  }
  lighten(ratio) {
    modHSL(this._rgb, 2, ratio);
    return this;
  }
  darken(ratio) {
    modHSL(this._rgb, 2, -ratio);
    return this;
  }
  saturate(ratio) {
    modHSL(this._rgb, 1, ratio);
    return this;
  }
  desaturate(ratio) {
    modHSL(this._rgb, 1, -ratio);
    return this;
  }
  rotate(deg) {
    rotate(this._rgb, deg);
    return this;
  }
};

// node_modules/.pnpm/chart.js@4.5.1/node_modules/chart.js/dist/chunks/helpers.dataset.js
function noop() {
}
var uid = /* @__PURE__ */ (() => {
  let id2 = 0;
  return () => id2++;
})();
function isNullOrUndef(value) {
  return value === null || value === void 0;
}
function isArray(value) {
  if (Array.isArray && Array.isArray(value)) {
    return true;
  }
  const type = Object.prototype.toString.call(value);
  if (type.slice(0, 7) === "[object" && type.slice(-6) === "Array]") {
    return true;
  }
  return false;
}
function isObject(value) {
  return value !== null && Object.prototype.toString.call(value) === "[object Object]";
}
function isNumberFinite(value) {
  return (typeof value === "number" || value instanceof Number) && isFinite(+value);
}
function finiteOrDefault(value, defaultValue) {
  return isNumberFinite(value) ? value : defaultValue;
}
function valueOrDefault(value, defaultValue) {
  return typeof value === "undefined" ? defaultValue : value;
}
var toPercentage = (value, dimension) => typeof value === "string" && value.endsWith("%") ? parseFloat(value) / 100 : +value / dimension;
var toDimension = (value, dimension) => typeof value === "string" && value.endsWith("%") ? parseFloat(value) / 100 * dimension : +value;
function callback(fn2, args, thisArg) {
  if (fn2 && typeof fn2.call === "function") {
    return fn2.apply(thisArg, args);
  }
}
function each(loopable, fn2, thisArg, reverse) {
  let i2, len, keys;
  if (isArray(loopable)) {
    len = loopable.length;
    if (reverse) {
      for (i2 = len - 1; i2 >= 0; i2--) {
        fn2.call(thisArg, loopable[i2], i2);
      }
    } else {
      for (i2 = 0; i2 < len; i2++) {
        fn2.call(thisArg, loopable[i2], i2);
      }
    }
  } else if (isObject(loopable)) {
    keys = Object.keys(loopable);
    len = keys.length;
    for (i2 = 0; i2 < len; i2++) {
      fn2.call(thisArg, loopable[keys[i2]], keys[i2]);
    }
  }
}
function _elementsEqual(a0, a1) {
  let i2, ilen, v0, v1;
  if (!a0 || !a1 || a0.length !== a1.length) {
    return false;
  }
  for (i2 = 0, ilen = a0.length; i2 < ilen; ++i2) {
    v0 = a0[i2];
    v1 = a1[i2];
    if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
      return false;
    }
  }
  return true;
}
function clone2(source) {
  if (isArray(source)) {
    return source.map(clone2);
  }
  if (isObject(source)) {
    const target = /* @__PURE__ */ Object.create(null);
    const keys = Object.keys(source);
    const klen = keys.length;
    let k = 0;
    for (; k < klen; ++k) {
      target[keys[k]] = clone2(source[keys[k]]);
    }
    return target;
  }
  return source;
}
function isValidKey(key) {
  return [
    "__proto__",
    "prototype",
    "constructor"
  ].indexOf(key) === -1;
}
function _merger(key, target, source, options) {
  if (!isValidKey(key)) {
    return;
  }
  const tval = target[key];
  const sval = source[key];
  if (isObject(tval) && isObject(sval)) {
    merge(tval, sval, options);
  } else {
    target[key] = clone2(sval);
  }
}
function merge(target, source, options) {
  const sources = isArray(source) ? source : [
    source
  ];
  const ilen = sources.length;
  if (!isObject(target)) {
    return target;
  }
  options = options || {};
  const merger = options.merger || _merger;
  let current;
  for (let i2 = 0; i2 < ilen; ++i2) {
    current = sources[i2];
    if (!isObject(current)) {
      continue;
    }
    const keys = Object.keys(current);
    for (let k = 0, klen = keys.length; k < klen; ++k) {
      merger(keys[k], target, current, options);
    }
  }
  return target;
}
function mergeIf(target, source) {
  return merge(target, source, {
    merger: _mergerIf
  });
}
function _mergerIf(key, target, source) {
  if (!isValidKey(key)) {
    return;
  }
  const tval = target[key];
  const sval = source[key];
  if (isObject(tval) && isObject(sval)) {
    mergeIf(tval, sval);
  } else if (!Object.prototype.hasOwnProperty.call(target, key)) {
    target[key] = clone2(sval);
  }
}
var keyResolvers = {
  // Chart.helpers.core resolveObjectKey should resolve empty key to root object
  "": (v2) => v2,
  // default resolvers
  x: (o2) => o2.x,
  y: (o2) => o2.y
};
function _splitKey(key) {
  const parts = key.split(".");
  const keys = [];
  let tmp = "";
  for (const part of parts) {
    tmp += part;
    if (tmp.endsWith("\\")) {
      tmp = tmp.slice(0, -1) + ".";
    } else {
      keys.push(tmp);
      tmp = "";
    }
  }
  return keys;
}
function _getKeyResolver(key) {
  const keys = _splitKey(key);
  return (obj) => {
    for (const k of keys) {
      if (k === "") {
        break;
      }
      obj = obj && obj[k];
    }
    return obj;
  };
}
function resolveObjectKey(obj, key) {
  const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key));
  return resolver(obj);
}
function _capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
var defined = (value) => typeof value !== "undefined";
var isFunction = (value) => typeof value === "function";
var setsEqual = (a2, b2) => {
  if (a2.size !== b2.size) {
    return false;
  }
  for (const item of a2) {
    if (!b2.has(item)) {
      return false;
    }
  }
  return true;
};
function _isClickEvent(e2) {
  return e2.type === "mouseup" || e2.type === "click" || e2.type === "contextmenu";
}
var PI = Math.PI;
var TAU = 2 * PI;
var PITAU = TAU + PI;
var INFINITY = Number.POSITIVE_INFINITY;
var RAD_PER_DEG = PI / 180;
var HALF_PI = PI / 2;
var QUARTER_PI = PI / 4;
var TWO_THIRDS_PI = PI * 2 / 3;
var log10 = Math.log10;
var sign = Math.sign;
function almostEquals(x2, y2, epsilon) {
  return Math.abs(x2 - y2) < epsilon;
}
function niceNum(range2) {
  const roundedRange = Math.round(range2);
  range2 = almostEquals(range2, roundedRange, range2 / 1e3) ? roundedRange : range2;
  const niceRange = Math.pow(10, Math.floor(log10(range2)));
  const fraction = range2 / niceRange;
  const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
  return niceFraction * niceRange;
}
function _factorize(value) {
  const result = [];
  const sqrt = Math.sqrt(value);
  let i2;
  for (i2 = 1; i2 < sqrt; i2++) {
    if (value % i2 === 0) {
      result.push(i2);
      result.push(value / i2);
    }
  }
  if (sqrt === (sqrt | 0)) {
    result.push(sqrt);
  }
  result.sort((a2, b2) => a2 - b2).pop();
  return result;
}
function isNonPrimitive(n2) {
  return typeof n2 === "symbol" || typeof n2 === "object" && n2 !== null && !(Symbol.toPrimitive in n2 || "toString" in n2 || "valueOf" in n2);
}
function isNumber(n2) {
  return !isNonPrimitive(n2) && !isNaN(parseFloat(n2)) && isFinite(n2);
}
function almostWhole(x2, epsilon) {
  const rounded = Math.round(x2);
  return rounded - epsilon <= x2 && rounded + epsilon >= x2;
}
function _setMinAndMaxByKey(array, target, property) {
  let i2, ilen, value;
  for (i2 = 0, ilen = array.length; i2 < ilen; i2++) {
    value = array[i2][property];
    if (!isNaN(value)) {
      target.min = Math.min(target.min, value);
      target.max = Math.max(target.max, value);
    }
  }
}
function toRadians(degrees) {
  return degrees * (PI / 180);
}
function toDegrees(radians) {
  return radians * (180 / PI);
}
function _decimalPlaces(x2) {
  if (!isNumberFinite(x2)) {
    return;
  }
  let e2 = 1;
  let p2 = 0;
  while (Math.round(x2 * e2) / e2 !== x2) {
    e2 *= 10;
    p2++;
  }
  return p2;
}
function getAngleFromPoint(centrePoint, anglePoint) {
  const distanceFromXCenter = anglePoint.x - centrePoint.x;
  const distanceFromYCenter = anglePoint.y - centrePoint.y;
  const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
  let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
  if (angle < -0.5 * PI) {
    angle += TAU;
  }
  return {
    angle,
    distance: radialDistanceFromCenter
  };
}
function distanceBetweenPoints(pt1, pt22) {
  return Math.sqrt(Math.pow(pt22.x - pt1.x, 2) + Math.pow(pt22.y - pt1.y, 2));
}
function _normalizeAngle(a2) {
  return (a2 % TAU + TAU) % TAU;
}
function _angleBetween(angle, start, end, sameAngleIsFullCircle) {
  const a2 = _normalizeAngle(angle);
  const s2 = _normalizeAngle(start);
  const e2 = _normalizeAngle(end);
  const angleToStart = _normalizeAngle(s2 - a2);
  const angleToEnd = _normalizeAngle(e2 - a2);
  const startToAngle = _normalizeAngle(a2 - s2);
  const endToAngle = _normalizeAngle(a2 - e2);
  return a2 === s2 || a2 === e2 || sameAngleIsFullCircle && s2 === e2 || angleToStart > angleToEnd && startToAngle < endToAngle;
}
function _limitValue(value, min, max) {
  return Math.max(min, Math.min(max, value));
}
function _int16Range(value) {
  return _limitValue(value, -32768, 32767);
}
function _isBetween(value, start, end, epsilon = 1e-6) {
  return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;
}
function _lookup(table, value, cmp) {
  cmp = cmp || ((index) => table[index] < value);
  let hi2 = table.length - 1;
  let lo = 0;
  let mid;
  while (hi2 - lo > 1) {
    mid = lo + hi2 >> 1;
    if (cmp(mid)) {
      lo = mid;
    } else {
      hi2 = mid;
    }
  }
  return {
    lo,
    hi: hi2
  };
}
var _lookupByKey = (table, key, value, last) => _lookup(table, value, last ? (index) => {
  const ti = table[index][key];
  return ti < value || ti === value && table[index + 1][key] === value;
} : (index) => table[index][key] < value);
var _rlookupByKey = (table, key, value) => _lookup(table, value, (index) => table[index][key] >= value);
function _filterBetween(values, min, max) {
  let start = 0;
  let end = values.length;
  while (start < end && values[start] < min) {
    start++;
  }
  while (end > start && values[end - 1] > max) {
    end--;
  }
  return start > 0 || end < values.length ? values.slice(start, end) : values;
}
var arrayEvents = [
  "push",
  "pop",
  "shift",
  "splice",
  "unshift"
];
function listenArrayEvents(array, listener) {
  if (array._chartjs) {
    array._chartjs.listeners.push(listener);
    return;
  }
  Object.defineProperty(array, "_chartjs", {
    configurable: true,
    enumerable: false,
    value: {
      listeners: [
        listener
      ]
    }
  });
  arrayEvents.forEach((key) => {
    const method = "_onData" + _capitalize(key);
    const base = array[key];
    Object.defineProperty(array, key, {
      configurable: true,
      enumerable: false,
      value(...args) {
        const res = base.apply(this, args);
        array._chartjs.listeners.forEach((object) => {
          if (typeof object[method] === "function") {
            object[method](...args);
          }
        });
        return res;
      }
    });
  });
}
function unlistenArrayEvents(array, listener) {
  const stub = array._chartjs;
  if (!stub) {
    return;
  }
  const listeners = stub.listeners;
  const index = listeners.indexOf(listener);
  if (index !== -1) {
    listeners.splice(index, 1);
  }
  if (listeners.length > 0) {
    return;
  }
  arrayEvents.forEach((key) => {
    delete array[key];
  });
  delete array._chartjs;
}
function _arrayUnique(items) {
  const set2 = new Set(items);
  if (set2.size === items.length) {
    return items;
  }
  return Array.from(set2);
}
var requestAnimFrame = (function() {
  if (typeof window === "undefined") {
    return function(callback2) {
      return callback2();
    };
  }
  return window.requestAnimationFrame;
})();
function throttled(fn2, thisArg) {
  let argsToUse = [];
  let ticking = false;
  return function(...args) {
    argsToUse = args;
    if (!ticking) {
      ticking = true;
      requestAnimFrame.call(window, () => {
        ticking = false;
        fn2.apply(thisArg, argsToUse);
      });
    }
  };
}
function debounce(fn2, delay) {
  let timeout;
  return function(...args) {
    if (delay) {
      clearTimeout(timeout);
      timeout = setTimeout(fn2, delay, args);
    } else {
      fn2.apply(this, args);
    }
    return delay;
  };
}
var _toLeftRightCenter = (align) => align === "start" ? "left" : align === "end" ? "right" : "center";
var _alignStartEnd = (align, start, end) => align === "start" ? start : align === "end" ? end : (start + end) / 2;
var _textX = (align, left, right, rtl) => {
  const check = rtl ? "left" : "right";
  return align === check ? right : align === "center" ? (left + right) / 2 : left;
};
var atEdge = (t3) => t3 === 0 || t3 === 1;
var elasticIn = (t3, s2, p2) => -(Math.pow(2, 10 * (t3 -= 1)) * Math.sin((t3 - s2) * TAU / p2));
var elasticOut = (t3, s2, p2) => Math.pow(2, -10 * t3) * Math.sin((t3 - s2) * TAU / p2) + 1;
var effects = {
  linear: (t3) => t3,
  easeInQuad: (t3) => t3 * t3,
  easeOutQuad: (t3) => -t3 * (t3 - 2),
  easeInOutQuad: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 : -0.5 * (--t3 * (t3 - 2) - 1),
  easeInCubic: (t3) => t3 * t3 * t3,
  easeOutCubic: (t3) => (t3 -= 1) * t3 * t3 + 1,
  easeInOutCubic: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 * t3 : 0.5 * ((t3 -= 2) * t3 * t3 + 2),
  easeInQuart: (t3) => t3 * t3 * t3 * t3,
  easeOutQuart: (t3) => -((t3 -= 1) * t3 * t3 * t3 - 1),
  easeInOutQuart: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 * t3 * t3 : -0.5 * ((t3 -= 2) * t3 * t3 * t3 - 2),
  easeInQuint: (t3) => t3 * t3 * t3 * t3 * t3,
  easeOutQuint: (t3) => (t3 -= 1) * t3 * t3 * t3 * t3 + 1,
  easeInOutQuint: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 * t3 * t3 * t3 : 0.5 * ((t3 -= 2) * t3 * t3 * t3 * t3 + 2),
  easeInSine: (t3) => -Math.cos(t3 * HALF_PI) + 1,
  easeOutSine: (t3) => Math.sin(t3 * HALF_PI),
  easeInOutSine: (t3) => -0.5 * (Math.cos(PI * t3) - 1),
  easeInExpo: (t3) => t3 === 0 ? 0 : Math.pow(2, 10 * (t3 - 1)),
  easeOutExpo: (t3) => t3 === 1 ? 1 : -Math.pow(2, -10 * t3) + 1,
  easeInOutExpo: (t3) => atEdge(t3) ? t3 : t3 < 0.5 ? 0.5 * Math.pow(2, 10 * (t3 * 2 - 1)) : 0.5 * (-Math.pow(2, -10 * (t3 * 2 - 1)) + 2),
  easeInCirc: (t3) => t3 >= 1 ? t3 : -(Math.sqrt(1 - t3 * t3) - 1),
  easeOutCirc: (t3) => Math.sqrt(1 - (t3 -= 1) * t3),
  easeInOutCirc: (t3) => (t3 /= 0.5) < 1 ? -0.5 * (Math.sqrt(1 - t3 * t3) - 1) : 0.5 * (Math.sqrt(1 - (t3 -= 2) * t3) + 1),
  easeInElastic: (t3) => atEdge(t3) ? t3 : elasticIn(t3, 0.075, 0.3),
  easeOutElastic: (t3) => atEdge(t3) ? t3 : elasticOut(t3, 0.075, 0.3),
  easeInOutElastic(t3) {
    const s2 = 0.1125;
    const p2 = 0.45;
    return atEdge(t3) ? t3 : t3 < 0.5 ? 0.5 * elasticIn(t3 * 2, s2, p2) : 0.5 + 0.5 * elasticOut(t3 * 2 - 1, s2, p2);
  },
  easeInBack(t3) {
    const s2 = 1.70158;
    return t3 * t3 * ((s2 + 1) * t3 - s2);
  },
  easeOutBack(t3) {
    const s2 = 1.70158;
    return (t3 -= 1) * t3 * ((s2 + 1) * t3 + s2) + 1;
  },
  easeInOutBack(t3) {
    let s2 = 1.70158;
    if ((t3 /= 0.5) < 1) {
      return 0.5 * (t3 * t3 * (((s2 *= 1.525) + 1) * t3 - s2));
    }
    return 0.5 * ((t3 -= 2) * t3 * (((s2 *= 1.525) + 1) * t3 + s2) + 2);
  },
  easeInBounce: (t3) => 1 - effects.easeOutBounce(1 - t3),
  easeOutBounce(t3) {
    const m2 = 7.5625;
    const d2 = 2.75;
    if (t3 < 1 / d2) {
      return m2 * t3 * t3;
    }
    if (t3 < 2 / d2) {
      return m2 * (t3 -= 1.5 / d2) * t3 + 0.75;
    }
    if (t3 < 2.5 / d2) {
      return m2 * (t3 -= 2.25 / d2) * t3 + 0.9375;
    }
    return m2 * (t3 -= 2.625 / d2) * t3 + 0.984375;
  },
  easeInOutBounce: (t3) => t3 < 0.5 ? effects.easeInBounce(t3 * 2) * 0.5 : effects.easeOutBounce(t3 * 2 - 1) * 0.5 + 0.5
};
function isPatternOrGradient(value) {
  if (value && typeof value === "object") {
    const type = value.toString();
    return type === "[object CanvasPattern]" || type === "[object CanvasGradient]";
  }
  return false;
}
function color(value) {
  return isPatternOrGradient(value) ? value : new Color(value);
}
function getHoverColor(value) {
  return isPatternOrGradient(value) ? value : new Color(value).saturate(0.5).darken(0.1).hexString();
}
var numbers = [
  "x",
  "y",
  "borderWidth",
  "radius",
  "tension"
];
var colors = [
  "color",
  "borderColor",
  "backgroundColor"
];
function applyAnimationsDefaults(defaults3) {
  defaults3.set("animation", {
    delay: void 0,
    duration: 1e3,
    easing: "easeOutQuart",
    fn: void 0,
    from: void 0,
    loop: void 0,
    to: void 0,
    type: void 0
  });
  defaults3.describe("animation", {
    _fallback: false,
    _indexable: false,
    _scriptable: (name) => name !== "onProgress" && name !== "onComplete" && name !== "fn"
  });
  defaults3.set("animations", {
    colors: {
      type: "color",
      properties: colors
    },
    numbers: {
      type: "number",
      properties: numbers
    }
  });
  defaults3.describe("animations", {
    _fallback: "animation"
  });
  defaults3.set("transitions", {
    active: {
      animation: {
        duration: 400
      }
    },
    resize: {
      animation: {
        duration: 0
      }
    },
    show: {
      animations: {
        colors: {
          from: "transparent"
        },
        visible: {
          type: "boolean",
          duration: 0
        }
      }
    },
    hide: {
      animations: {
        colors: {
          to: "transparent"
        },
        visible: {
          type: "boolean",
          easing: "linear",
          fn: (v2) => v2 | 0
        }
      }
    }
  });
}
function applyLayoutsDefaults(defaults3) {
  defaults3.set("layout", {
    autoPadding: true,
    padding: {
      top: 0,
      right: 0,
      bottom: 0,
      left: 0
    }
  });
}
var intlCache = /* @__PURE__ */ new Map();
function getNumberFormat(locale, options) {
  options = options || {};
  const cacheKey = locale + JSON.stringify(options);
  let formatter = intlCache.get(cacheKey);
  if (!formatter) {
    formatter = new Intl.NumberFormat(locale, options);
    intlCache.set(cacheKey, formatter);
  }
  return formatter;
}
function formatNumber(num, locale, options) {
  return getNumberFormat(locale, options).format(num);
}
var formatters = {
  values(value) {
    return isArray(value) ? value : "" + value;
  },
  numeric(tickValue, index, ticks) {
    if (tickValue === 0) {
      return "0";
    }
    const locale = this.chart.options.locale;
    let notation;
    let delta = tickValue;
    if (ticks.length > 1) {
      const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));
      if (maxTick < 1e-4 || maxTick > 1e15) {
        notation = "scientific";
      }
      delta = calculateDelta(tickValue, ticks);
    }
    const logDelta = log10(Math.abs(delta));
    const numDecimal = isNaN(logDelta) ? 1 : Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);
    const options = {
      notation,
      minimumFractionDigits: numDecimal,
      maximumFractionDigits: numDecimal
    };
    Object.assign(options, this.options.ticks.format);
    return formatNumber(tickValue, locale, options);
  },
  logarithmic(tickValue, index, ticks) {
    if (tickValue === 0) {
      return "0";
    }
    const remain = ticks[index].significand || tickValue / Math.pow(10, Math.floor(log10(tickValue)));
    if ([
      1,
      2,
      3,
      5,
      10,
      15
    ].includes(remain) || index > 0.8 * ticks.length) {
      return formatters.numeric.call(this, tickValue, index, ticks);
    }
    return "";
  }
};
function calculateDelta(tickValue, ticks) {
  let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;
  if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {
    delta = tickValue - Math.floor(tickValue);
  }
  return delta;
}
var Ticks = {
  formatters
};
function applyScaleDefaults(defaults3) {
  defaults3.set("scale", {
    display: true,
    offset: false,
    reverse: false,
    beginAtZero: false,
    bounds: "ticks",
    clip: true,
    grace: 0,
    grid: {
      display: true,
      lineWidth: 1,
      drawOnChartArea: true,
      drawTicks: true,
      tickLength: 8,
      tickWidth: (_ctx, options) => options.lineWidth,
      tickColor: (_ctx, options) => options.color,
      offset: false
    },
    border: {
      display: true,
      dash: [],
      dashOffset: 0,
      width: 1
    },
    title: {
      display: false,
      text: "",
      padding: {
        top: 4,
        bottom: 4
      }
    },
    ticks: {
      minRotation: 0,
      maxRotation: 50,
      mirror: false,
      textStrokeWidth: 0,
      textStrokeColor: "",
      padding: 3,
      display: true,
      autoSkip: true,
      autoSkipPadding: 3,
      labelOffset: 0,
      callback: Ticks.formatters.values,
      minor: {},
      major: {},
      align: "center",
      crossAlign: "near",
      showLabelBackdrop: false,
      backdropColor: "rgba(255, 255, 255, 0.75)",
      backdropPadding: 2
    }
  });
  defaults3.route("scale.ticks", "color", "", "color");
  defaults3.route("scale.grid", "color", "", "borderColor");
  defaults3.route("scale.border", "color", "", "borderColor");
  defaults3.route("scale.title", "color", "", "color");
  defaults3.describe("scale", {
    _fallback: false,
    _scriptable: (name) => !name.startsWith("before") && !name.startsWith("after") && name !== "callback" && name !== "parser",
    _indexable: (name) => name !== "borderDash" && name !== "tickBorderDash" && name !== "dash"
  });
  defaults3.describe("scales", {
    _fallback: "scale"
  });
  defaults3.describe("scale.ticks", {
    _scriptable: (name) => name !== "backdropPadding" && name !== "callback",
    _indexable: (name) => name !== "backdropPadding"
  });
}
var overrides = /* @__PURE__ */ Object.create(null);
var descriptors = /* @__PURE__ */ Object.create(null);
function getScope$1(node, key) {
  if (!key) {
    return node;
  }
  const keys = key.split(".");
  for (let i2 = 0, n2 = keys.length; i2 < n2; ++i2) {
    const k = keys[i2];
    node = node[k] || (node[k] = /* @__PURE__ */ Object.create(null));
  }
  return node;
}
function set(root, scope, values) {
  if (typeof scope === "string") {
    return merge(getScope$1(root, scope), values);
  }
  return merge(getScope$1(root, ""), scope);
}
var Defaults = class {
  constructor(_descriptors2, _appliers) {
    this.animation = void 0;
    this.backgroundColor = "rgba(0,0,0,0.1)";
    this.borderColor = "rgba(0,0,0,0.1)";
    this.color = "#666";
    this.datasets = {};
    this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio();
    this.elements = {};
    this.events = [
      "mousemove",
      "mouseout",
      "click",
      "touchstart",
      "touchmove"
    ];
    this.font = {
      family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
      size: 12,
      style: "normal",
      lineHeight: 1.2,
      weight: null
    };
    this.hover = {};
    this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor);
    this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor);
    this.hoverColor = (ctx, options) => getHoverColor(options.color);
    this.indexAxis = "x";
    this.interaction = {
      mode: "nearest",
      intersect: true,
      includeInvisible: false
    };
    this.maintainAspectRatio = true;
    this.onHover = null;
    this.onClick = null;
    this.parsing = true;
    this.plugins = {};
    this.responsive = true;
    this.scale = void 0;
    this.scales = {};
    this.showLine = true;
    this.drawActiveElementsOnTop = true;
    this.describe(_descriptors2);
    this.apply(_appliers);
  }
  set(scope, values) {
    return set(this, scope, values);
  }
  get(scope) {
    return getScope$1(this, scope);
  }
  describe(scope, values) {
    return set(descriptors, scope, values);
  }
  override(scope, values) {
    return set(overrides, scope, values);
  }
  route(scope, name, targetScope, targetName) {
    const scopeObject = getScope$1(this, scope);
    const targetScopeObject = getScope$1(this, targetScope);
    const privateName = "_" + name;
    Object.defineProperties(scopeObject, {
      [privateName]: {
        value: scopeObject[name],
        writable: true
      },
      [name]: {
        enumerable: true,
        get() {
          const local = this[privateName];
          const target = targetScopeObject[targetName];
          if (isObject(local)) {
            return Object.assign({}, target, local);
          }
          return valueOrDefault(local, target);
        },
        set(value) {
          this[privateName] = value;
        }
      }
    });
  }
  apply(appliers) {
    appliers.forEach((apply) => apply(this));
  }
};
var defaults2 = /* @__PURE__ */ new Defaults({
  _scriptable: (name) => !name.startsWith("on"),
  _indexable: (name) => name !== "events",
  hover: {
    _fallback: "interaction"
  },
  interaction: {
    _scriptable: false,
    _indexable: false
  }
}, [
  applyAnimationsDefaults,
  applyLayoutsDefaults,
  applyScaleDefaults
]);
function toFontString(font) {
  if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {
    return null;
  }
  return (font.style ? font.style + " " : "") + (font.weight ? font.weight + " " : "") + font.size + "px " + font.family;
}
function _measureText(ctx, data, gc, longest, string) {
  let textWidth = data[string];
  if (!textWidth) {
    textWidth = data[string] = ctx.measureText(string).width;
    gc.push(string);
  }
  if (textWidth > longest) {
    longest = textWidth;
  }
  return longest;
}
function _longestText(ctx, font, arrayOfThings, cache) {
  cache = cache || {};
  let data = cache.data = cache.data || {};
  let gc = cache.garbageCollect = cache.garbageCollect || [];
  if (cache.font !== font) {
    data = cache.data = {};
    gc = cache.garbageCollect = [];
    cache.font = font;
  }
  ctx.save();
  ctx.font = font;
  let longest = 0;
  const ilen = arrayOfThings.length;
  let i2, j2, jlen, thing, nestedThing;
  for (i2 = 0; i2 < ilen; i2++) {
    thing = arrayOfThings[i2];
    if (thing !== void 0 && thing !== null && !isArray(thing)) {
      longest = _measureText(ctx, data, gc, longest, thing);
    } else if (isArray(thing)) {
      for (j2 = 0, jlen = thing.length; j2 < jlen; j2++) {
        nestedThing = thing[j2];
        if (nestedThing !== void 0 && nestedThing !== null && !isArray(nestedThing)) {
          longest = _measureText(ctx, data, gc, longest, nestedThing);
        }
      }
    }
  }
  ctx.restore();
  const gcLen = gc.length / 2;
  if (gcLen > arrayOfThings.length) {
    for (i2 = 0; i2 < gcLen; i2++) {
      delete data[gc[i2]];
    }
    gc.splice(0, gcLen);
  }
  return longest;
}
function _alignPixel(chart, pixel, width) {
  const devicePixelRatio = chart.currentDevicePixelRatio;
  const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;
  return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
}
function clearCanvas(canvas, ctx) {
  if (!ctx && !canvas) {
    return;
  }
  ctx = ctx || canvas.getContext("2d");
  ctx.save();
  ctx.resetTransform();
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  ctx.restore();
}
function drawPoint(ctx, options, x2, y2) {
  drawPointLegend(ctx, options, x2, y2, null);
}
function drawPointLegend(ctx, options, x2, y2, w2) {
  let type, xOffset, yOffset, size, cornerRadius, width, xOffsetW, yOffsetW;
  const style = options.pointStyle;
  const rotation = options.rotation;
  const radius = options.radius;
  let rad = (rotation || 0) * RAD_PER_DEG;
  if (style && typeof style === "object") {
    type = style.toString();
    if (type === "[object HTMLImageElement]" || type === "[object HTMLCanvasElement]") {
      ctx.save();
      ctx.translate(x2, y2);
      ctx.rotate(rad);
      ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
      ctx.restore();
      return;
    }
  }
  if (isNaN(radius) || radius <= 0) {
    return;
  }
  ctx.beginPath();
  switch (style) {
    // Default includes circle
    default:
      if (w2) {
        ctx.ellipse(x2, y2, w2 / 2, radius, 0, 0, TAU);
      } else {
        ctx.arc(x2, y2, radius, 0, TAU);
      }
      ctx.closePath();
      break;
    case "triangle":
      width = w2 ? w2 / 2 : radius;
      ctx.moveTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
      rad += TWO_THIRDS_PI;
      ctx.lineTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
      rad += TWO_THIRDS_PI;
      ctx.lineTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
      ctx.closePath();
      break;
    case "rectRounded":
      cornerRadius = radius * 0.516;
      size = radius - cornerRadius;
      xOffset = Math.cos(rad + QUARTER_PI) * size;
      xOffsetW = Math.cos(rad + QUARTER_PI) * (w2 ? w2 / 2 - cornerRadius : size);
      yOffset = Math.sin(rad + QUARTER_PI) * size;
      yOffsetW = Math.sin(rad + QUARTER_PI) * (w2 ? w2 / 2 - cornerRadius : size);
      ctx.arc(x2 - xOffsetW, y2 - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
      ctx.arc(x2 + yOffsetW, y2 - xOffset, cornerRadius, rad - HALF_PI, rad);
      ctx.arc(x2 + xOffsetW, y2 + yOffset, cornerRadius, rad, rad + HALF_PI);
      ctx.arc(x2 - yOffsetW, y2 + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
      ctx.closePath();
      break;
    case "rect":
      if (!rotation) {
        size = Math.SQRT1_2 * radius;
        width = w2 ? w2 / 2 : size;
        ctx.rect(x2 - width, y2 - size, 2 * width, 2 * size);
        break;
      }
      rad += QUARTER_PI;
    /* falls through */
    case "rectRot":
      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
      xOffset = Math.cos(rad) * radius;
      yOffset = Math.sin(rad) * radius;
      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
      ctx.lineTo(x2 + yOffsetW, y2 - xOffset);
      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
      ctx.closePath();
      break;
    case "crossRot":
      rad += QUARTER_PI;
    /* falls through */
    case "cross":
      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
      xOffset = Math.cos(rad) * radius;
      yOffset = Math.sin(rad) * radius;
      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
      ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
      break;
    case "star":
      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
      xOffset = Math.cos(rad) * radius;
      yOffset = Math.sin(rad) * radius;
      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
      ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
      rad += QUARTER_PI;
      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
      xOffset = Math.cos(rad) * radius;
      yOffset = Math.sin(rad) * radius;
      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
      ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
      break;
    case "line":
      xOffset = w2 ? w2 / 2 : Math.cos(rad) * radius;
      yOffset = Math.sin(rad) * radius;
      ctx.moveTo(x2 - xOffset, y2 - yOffset);
      ctx.lineTo(x2 + xOffset, y2 + yOffset);
      break;
    case "dash":
      ctx.moveTo(x2, y2);
      ctx.lineTo(x2 + Math.cos(rad) * (w2 ? w2 / 2 : radius), y2 + Math.sin(rad) * radius);
      break;
    case false:
      ctx.closePath();
      break;
  }
  ctx.fill();
  if (options.borderWidth > 0) {
    ctx.stroke();
  }
}
function _isPointInArea(point, area, margin) {
  margin = margin || 0.5;
  return !area || point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;
}
function clipArea(ctx, area) {
  ctx.save();
  ctx.beginPath();
  ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
  ctx.clip();
}
function unclipArea(ctx) {
  ctx.restore();
}
function setRenderOpts(ctx, opts) {
  if (opts.translation) {
    ctx.translate(opts.translation[0], opts.translation[1]);
  }
  if (!isNullOrUndef(opts.rotation)) {
    ctx.rotate(opts.rotation);
  }
  if (opts.color) {
    ctx.fillStyle = opts.color;
  }
  if (opts.textAlign) {
    ctx.textAlign = opts.textAlign;
  }
  if (opts.textBaseline) {
    ctx.textBaseline = opts.textBaseline;
  }
}
function decorateText(ctx, x2, y2, line, opts) {
  if (opts.strikethrough || opts.underline) {
    const metrics = ctx.measureText(line);
    const left = x2 - metrics.actualBoundingBoxLeft;
    const right = x2 + metrics.actualBoundingBoxRight;
    const top = y2 - metrics.actualBoundingBoxAscent;
    const bottom = y2 + metrics.actualBoundingBoxDescent;
    const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;
    ctx.strokeStyle = ctx.fillStyle;
    ctx.beginPath();
    ctx.lineWidth = opts.decorationWidth || 2;
    ctx.moveTo(left, yDecoration);
    ctx.lineTo(right, yDecoration);
    ctx.stroke();
  }
}
function drawBackdrop(ctx, opts) {
  const oldColor = ctx.fillStyle;
  ctx.fillStyle = opts.color;
  ctx.fillRect(opts.left, opts.top, opts.width, opts.height);
  ctx.fillStyle = oldColor;
}
function renderText(ctx, text, x2, y2, font, opts = {}) {
  const lines = isArray(text) ? text : [
    text
  ];
  const stroke = opts.strokeWidth > 0 && opts.strokeColor !== "";
  let i2, line;
  ctx.save();
  ctx.font = font.string;
  setRenderOpts(ctx, opts);
  for (i2 = 0; i2 < lines.length; ++i2) {
    line = lines[i2];
    if (opts.backdrop) {
      drawBackdrop(ctx, opts.backdrop);
    }
    if (stroke) {
      if (opts.strokeColor) {
        ctx.strokeStyle = opts.strokeColor;
      }
      if (!isNullOrUndef(opts.strokeWidth)) {
        ctx.lineWidth = opts.strokeWidth;
      }
      ctx.strokeText(line, x2, y2, opts.maxWidth);
    }
    ctx.fillText(line, x2, y2, opts.maxWidth);
    decorateText(ctx, x2, y2, line, opts);
    y2 += Number(font.lineHeight);
  }
  ctx.restore();
}
function addRoundedRectPath(ctx, rect) {
  const { x: x2, y: y2, w: w2, h: h3, radius } = rect;
  ctx.arc(x2 + radius.topLeft, y2 + radius.topLeft, radius.topLeft, 1.5 * PI, PI, true);
  ctx.lineTo(x2, y2 + h3 - radius.bottomLeft);
  ctx.arc(x2 + radius.bottomLeft, y2 + h3 - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);
  ctx.lineTo(x2 + w2 - radius.bottomRight, y2 + h3);
  ctx.arc(x2 + w2 - radius.bottomRight, y2 + h3 - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);
  ctx.lineTo(x2 + w2, y2 + radius.topRight);
  ctx.arc(x2 + w2 - radius.topRight, y2 + radius.topRight, radius.topRight, 0, -HALF_PI, true);
  ctx.lineTo(x2 + radius.topLeft, y2);
}
var LINE_HEIGHT = /^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/;
var FONT_STYLE = /^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;
function toLineHeight(value, size) {
  const matches = ("" + value).match(LINE_HEIGHT);
  if (!matches || matches[1] === "normal") {
    return size * 1.2;
  }
  value = +matches[2];
  switch (matches[3]) {
    case "px":
      return value;
    case "%":
      value /= 100;
      break;
  }
  return size * value;
}
var numberOrZero = (v2) => +v2 || 0;
function _readValueToProps(value, props) {
  const ret = {};
  const objProps = isObject(props);
  const keys = objProps ? Object.keys(props) : props;
  const read = isObject(value) ? objProps ? (prop) => valueOrDefault(value[prop], value[props[prop]]) : (prop) => value[prop] : () => value;
  for (const prop of keys) {
    ret[prop] = numberOrZero(read(prop));
  }
  return ret;
}
function toTRBL(value) {
  return _readValueToProps(value, {
    top: "y",
    right: "x",
    bottom: "y",
    left: "x"
  });
}
function toTRBLCorners(value) {
  return _readValueToProps(value, [
    "topLeft",
    "topRight",
    "bottomLeft",
    "bottomRight"
  ]);
}
function toPadding(value) {
  const obj = toTRBL(value);
  obj.width = obj.left + obj.right;
  obj.height = obj.top + obj.bottom;
  return obj;
}
function toFont(options, fallback) {
  options = options || {};
  fallback = fallback || defaults2.font;
  let size = valueOrDefault(options.size, fallback.size);
  if (typeof size === "string") {
    size = parseInt(size, 10);
  }
  let style = valueOrDefault(options.style, fallback.style);
  if (style && !("" + style).match(FONT_STYLE)) {
    console.warn('Invalid font style specified: "' + style + '"');
    style = void 0;
  }
  const font = {
    family: valueOrDefault(options.family, fallback.family),
    lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),
    size,
    style,
    weight: valueOrDefault(options.weight, fallback.weight),
    string: ""
  };
  font.string = toFontString(font);
  return font;
}
function resolve(inputs, context, index, info) {
  let cacheable = true;
  let i2, ilen, value;
  for (i2 = 0, ilen = inputs.length; i2 < ilen; ++i2) {
    value = inputs[i2];
    if (value === void 0) {
      continue;
    }
    if (context !== void 0 && typeof value === "function") {
      value = value(context);
      cacheable = false;
    }
    if (index !== void 0 && isArray(value)) {
      value = value[index % value.length];
      cacheable = false;
    }
    if (value !== void 0) {
      if (info && !cacheable) {
        info.cacheable = false;
      }
      return value;
    }
  }
}
function _addGrace(minmax, grace, beginAtZero) {
  const { min, max } = minmax;
  const change = toDimension(grace, (max - min) / 2);
  const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add;
  return {
    min: keepZero(min, -Math.abs(change)),
    max: keepZero(max, change)
  };
}
function createContext(parentContext, context) {
  return Object.assign(Object.create(parentContext), context);
}
function _createResolver(scopes, prefixes = [
  ""
], rootScopes, fallback, getTarget = () => scopes[0]) {
  const finalRootScopes = rootScopes || scopes;
  if (typeof fallback === "undefined") {
    fallback = _resolve("_fallback", scopes);
  }
  const cache = {
    [Symbol.toStringTag]: "Object",
    _cacheable: true,
    _scopes: scopes,
    _rootScopes: finalRootScopes,
    _fallback: fallback,
    _getTarget: getTarget,
    override: (scope) => _createResolver([
      scope,
      ...scopes
    ], prefixes, finalRootScopes, fallback)
  };
  return new Proxy(cache, {
    /**
    * A trap for the delete operator.
    */
    deleteProperty(target, prop) {
      delete target[prop];
      delete target._keys;
      delete scopes[0][prop];
      return true;
    },
    /**
    * A trap for getting property values.
    */
    get(target, prop) {
      return _cached(target, prop, () => _resolveWithPrefixes(prop, prefixes, scopes, target));
    },
    /**
    * A trap for Object.getOwnPropertyDescriptor.
    * Also used by Object.hasOwnProperty.
    */
    getOwnPropertyDescriptor(target, prop) {
      return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);
    },
    /**
    * A trap for Object.getPrototypeOf.
    */
    getPrototypeOf() {
      return Reflect.getPrototypeOf(scopes[0]);
    },
    /**
    * A trap for the in operator.
    */
    has(target, prop) {
      return getKeysFromAllScopes(target).includes(prop);
    },
    /**
    * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
    */
    ownKeys(target) {
      return getKeysFromAllScopes(target);
    },
    /**
    * A trap for setting property values.
    */
    set(target, prop, value) {
      const storage = target._storage || (target._storage = getTarget());
      target[prop] = storage[prop] = value;
      delete target._keys;
      return true;
    }
  });
}
function _attachContext(proxy, context, subProxy, descriptorDefaults) {
  const cache = {
    _cacheable: false,
    _proxy: proxy,
    _context: context,
    _subProxy: subProxy,
    _stack: /* @__PURE__ */ new Set(),
    _descriptors: _descriptors(proxy, descriptorDefaults),
    setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),
    override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)
  };
  return new Proxy(cache, {
    /**
    * A trap for the delete operator.
    */
    deleteProperty(target, prop) {
      delete target[prop];
      delete proxy[prop];
      return true;
    },
    /**
    * A trap for getting property values.
    */
    get(target, prop, receiver) {
      return _cached(target, prop, () => _resolveWithContext(target, prop, receiver));
    },
    /**
    * A trap for Object.getOwnPropertyDescriptor.
    * Also used by Object.hasOwnProperty.
    */
    getOwnPropertyDescriptor(target, prop) {
      return target._descriptors.allKeys ? Reflect.has(proxy, prop) ? {
        enumerable: true,
        configurable: true
      } : void 0 : Reflect.getOwnPropertyDescriptor(proxy, prop);
    },
    /**
    * A trap for Object.getPrototypeOf.
    */
    getPrototypeOf() {
      return Reflect.getPrototypeOf(proxy);
    },
    /**
    * A trap for the in operator.
    */
    has(target, prop) {
      return Reflect.has(proxy, prop);
    },
    /**
    * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
    */
    ownKeys() {
      return Reflect.ownKeys(proxy);
    },
    /**
    * A trap for setting property values.
    */
    set(target, prop, value) {
      proxy[prop] = value;
      delete target[prop];
      return true;
    }
  });
}
function _descriptors(proxy, defaults3 = {
  scriptable: true,
  indexable: true
}) {
  const { _scriptable = defaults3.scriptable, _indexable = defaults3.indexable, _allKeys = defaults3.allKeys } = proxy;
  return {
    allKeys: _allKeys,
    scriptable: _scriptable,
    indexable: _indexable,
    isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable,
    isIndexable: isFunction(_indexable) ? _indexable : () => _indexable
  };
}
var readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;
var needsSubResolver = (prop, value) => isObject(value) && prop !== "adapters" && (Object.getPrototypeOf(value) === null || value.constructor === Object);
function _cached(target, prop, resolve2) {
  if (Object.prototype.hasOwnProperty.call(target, prop) || prop === "constructor") {
    return target[prop];
  }
  const value = resolve2();
  target[prop] = value;
  return value;
}
function _resolveWithContext(target, prop, receiver) {
  const { _proxy, _context, _subProxy, _descriptors: descriptors2 } = target;
  let value = _proxy[prop];
  if (isFunction(value) && descriptors2.isScriptable(prop)) {
    value = _resolveScriptable(prop, value, target, receiver);
  }
  if (isArray(value) && value.length) {
    value = _resolveArray(prop, value, target, descriptors2.isIndexable);
  }
  if (needsSubResolver(prop, value)) {
    value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors2);
  }
  return value;
}
function _resolveScriptable(prop, getValue, target, receiver) {
  const { _proxy, _context, _subProxy, _stack } = target;
  if (_stack.has(prop)) {
    throw new Error("Recursion detected: " + Array.from(_stack).join("->") + "->" + prop);
  }
  _stack.add(prop);
  let value = getValue(_context, _subProxy || receiver);
  _stack.delete(prop);
  if (needsSubResolver(prop, value)) {
    value = createSubResolver(_proxy._scopes, _proxy, prop, value);
  }
  return value;
}
function _resolveArray(prop, value, target, isIndexable) {
  const { _proxy, _context, _subProxy, _descriptors: descriptors2 } = target;
  if (typeof _context.index !== "undefined" && isIndexable(prop)) {
    return value[_context.index % value.length];
  } else if (isObject(value[0])) {
    const arr = value;
    const scopes = _proxy._scopes.filter((s2) => s2 !== arr);
    value = [];
    for (const item of arr) {
      const resolver = createSubResolver(scopes, _proxy, prop, item);
      value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors2));
    }
  }
  return value;
}
function resolveFallback(fallback, prop, value) {
  return isFunction(fallback) ? fallback(prop, value) : fallback;
}
var getScope = (key, parent) => key === true ? parent : typeof key === "string" ? resolveObjectKey(parent, key) : void 0;
function addScopes(set2, parentScopes, key, parentFallback, value) {
  for (const parent of parentScopes) {
    const scope = getScope(key, parent);
    if (scope) {
      set2.add(scope);
      const fallback = resolveFallback(scope._fallback, key, value);
      if (typeof fallback !== "undefined" && fallback !== key && fallback !== parentFallback) {
        return fallback;
      }
    } else if (scope === false && typeof parentFallback !== "undefined" && key !== parentFallback) {
      return null;
    }
  }
  return false;
}
function createSubResolver(parentScopes, resolver, prop, value) {
  const rootScopes = resolver._rootScopes;
  const fallback = resolveFallback(resolver._fallback, prop, value);
  const allScopes = [
    ...parentScopes,
    ...rootScopes
  ];
  const set2 = /* @__PURE__ */ new Set();
  set2.add(value);
  let key = addScopesFromKey(set2, allScopes, prop, fallback || prop, value);
  if (key === null) {
    return false;
  }
  if (typeof fallback !== "undefined" && fallback !== prop) {
    key = addScopesFromKey(set2, allScopes, fallback, key, value);
    if (key === null) {
      return false;
    }
  }
  return _createResolver(Array.from(set2), [
    ""
  ], rootScopes, fallback, () => subGetTarget(resolver, prop, value));
}
function addScopesFromKey(set2, allScopes, key, fallback, item) {
  while (key) {
    key = addScopes(set2, allScopes, key, fallback, item);
  }
  return key;
}
function subGetTarget(resolver, prop, value) {
  const parent = resolver._getTarget();
  if (!(prop in parent)) {
    parent[prop] = {};
  }
  const target = parent[prop];
  if (isArray(target) && isObject(value)) {
    return value;
  }
  return target || {};
}
function _resolveWithPrefixes(prop, prefixes, scopes, proxy) {
  let value;
  for (const prefix of prefixes) {
    value = _resolve(readKey(prefix, prop), scopes);
    if (typeof value !== "undefined") {
      return needsSubResolver(prop, value) ? createSubResolver(scopes, proxy, prop, value) : value;
    }
  }
}
function _resolve(key, scopes) {
  for (const scope of scopes) {
    if (!scope) {
      continue;
    }
    const value = scope[key];
    if (typeof value !== "undefined") {
      return value;
    }
  }
}
function getKeysFromAllScopes(target) {
  let keys = target._keys;
  if (!keys) {
    keys = target._keys = resolveKeysFromAllScopes(target._scopes);
  }
  return keys;
}
function resolveKeysFromAllScopes(scopes) {
  const set2 = /* @__PURE__ */ new Set();
  for (const scope of scopes) {
    for (const key of Object.keys(scope).filter((k) => !k.startsWith("_"))) {
      set2.add(key);
    }
  }
  return Array.from(set2);
}
var EPSILON = Number.EPSILON || 1e-14;
function _isDomSupported() {
  return typeof window !== "undefined" && typeof document !== "undefined";
}
function _getParentNode(domNode) {
  let parent = domNode.parentNode;
  if (parent && parent.toString() === "[object ShadowRoot]") {
    parent = parent.host;
  }
  return parent;
}
function parseMaxStyle(styleValue, node, parentProperty) {
  let valueInPixels;
  if (typeof styleValue === "string") {
    valueInPixels = parseInt(styleValue, 10);
    if (styleValue.indexOf("%") !== -1) {
      valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
    }
  } else {
    valueInPixels = styleValue;
  }
  return valueInPixels;
}
var getComputedStyle2 = (element) => element.ownerDocument.defaultView.getComputedStyle(element, null);
function getStyle(el, property) {
  return getComputedStyle2(el).getPropertyValue(property);
}
var positions = [
  "top",
  "right",
  "bottom",
  "left"
];
function getPositionedStyle(styles, style, suffix) {
  const result = {};
  suffix = suffix ? "-" + suffix : "";
  for (let i2 = 0; i2 < 4; i2++) {
    const pos = positions[i2];
    result[pos] = parseFloat(styles[style + "-" + pos + suffix]) || 0;
  }
  result.width = result.left + result.right;
  result.height = result.top + result.bottom;
  return result;
}
var useOffsetPos = (x2, y2, target) => (x2 > 0 || y2 > 0) && (!target || !target.shadowRoot);
function getCanvasPosition(e2, canvas) {
  const touches = e2.touches;
  const source = touches && touches.length ? touches[0] : e2;
  const { offsetX, offsetY } = source;
  let box = false;
  let x2, y2;
  if (useOffsetPos(offsetX, offsetY, e2.target)) {
    x2 = offsetX;
    y2 = offsetY;
  } else {
    const rect = canvas.getBoundingClientRect();
    x2 = source.clientX - rect.left;
    y2 = source.clientY - rect.top;
    box = true;
  }
  return {
    x: x2,
    y: y2,
    box
  };
}
function getRelativePosition(event, chart) {
  if ("native" in event) {
    return event;
  }
  const { canvas, currentDevicePixelRatio } = chart;
  const style = getComputedStyle2(canvas);
  const borderBox = style.boxSizing === "border-box";
  const paddings = getPositionedStyle(style, "padding");
  const borders = getPositionedStyle(style, "border", "width");
  const { x: x2, y: y2, box } = getCanvasPosition(event, canvas);
  const xOffset = paddings.left + (box && borders.left);
  const yOffset = paddings.top + (box && borders.top);
  let { width, height } = chart;
  if (borderBox) {
    width -= paddings.width + borders.width;
    height -= paddings.height + borders.height;
  }
  return {
    x: Math.round((x2 - xOffset) / width * canvas.width / currentDevicePixelRatio),
    y: Math.round((y2 - yOffset) / height * canvas.height / currentDevicePixelRatio)
  };
}
function getContainerSize(canvas, width, height) {
  let maxWidth, maxHeight;
  if (width === void 0 || height === void 0) {
    const container = canvas && _getParentNode(canvas);
    if (!container) {
      width = canvas.clientWidth;
      height = canvas.clientHeight;
    } else {
      const rect = container.getBoundingClientRect();
      const containerStyle = getComputedStyle2(container);
      const containerBorder = getPositionedStyle(containerStyle, "border", "width");
      const containerPadding = getPositionedStyle(containerStyle, "padding");
      width = rect.width - containerPadding.width - containerBorder.width;
      height = rect.height - containerPadding.height - containerBorder.height;
      maxWidth = parseMaxStyle(containerStyle.maxWidth, container, "clientWidth");
      maxHeight = parseMaxStyle(containerStyle.maxHeight, container, "clientHeight");
    }
  }
  return {
    width,
    height,
    maxWidth: maxWidth || INFINITY,
    maxHeight: maxHeight || INFINITY
  };
}
var round1 = (v2) => Math.round(v2 * 10) / 10;
function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {
  const style = getComputedStyle2(canvas);
  const margins = getPositionedStyle(style, "margin");
  const maxWidth = parseMaxStyle(style.maxWidth, canvas, "clientWidth") || INFINITY;
  const maxHeight = parseMaxStyle(style.maxHeight, canvas, "clientHeight") || INFINITY;
  const containerSize = getContainerSize(canvas, bbWidth, bbHeight);
  let { width, height } = containerSize;
  if (style.boxSizing === "content-box") {
    const borders = getPositionedStyle(style, "border", "width");
    const paddings = getPositionedStyle(style, "padding");
    width -= paddings.width + borders.width;
    height -= paddings.height + borders.height;
  }
  width = Math.max(0, width - margins.width);
  height = Math.max(0, aspectRatio ? width / aspectRatio : height - margins.height);
  width = round1(Math.min(width, maxWidth, containerSize.maxWidth));
  height = round1(Math.min(height, maxHeight, containerSize.maxHeight));
  if (width && !height) {
    height = round1(width / 2);
  }
  const maintainHeight = bbWidth !== void 0 || bbHeight !== void 0;
  if (maintainHeight && aspectRatio && containerSize.height && height > containerSize.height) {
    height = containerSize.height;
    width = round1(Math.floor(height * aspectRatio));
  }
  return {
    width,
    height
  };
}
function retinaScale(chart, forceRatio, forceStyle) {
  const pixelRatio = forceRatio || 1;
  const deviceHeight = round1(chart.height * pixelRatio);
  const deviceWidth = round1(chart.width * pixelRatio);
  chart.height = round1(chart.height);
  chart.width = round1(chart.width);
  const canvas = chart.canvas;
  if (canvas.style && (forceStyle || !canvas.style.height && !canvas.style.width)) {
    canvas.style.height = `${chart.height}px`;
    canvas.style.width = `${chart.width}px`;
  }
  if (chart.currentDevicePixelRatio !== pixelRatio || canvas.height !== deviceHeight || canvas.width !== deviceWidth) {
    chart.currentDevicePixelRatio = pixelRatio;
    canvas.height = deviceHeight;
    canvas.width = deviceWidth;
    chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
    return true;
  }
  return false;
}
var supportsEventListenerOptions = (function() {
  let passiveSupported = false;
  try {
    const options = {
      get passive() {
        passiveSupported = true;
        return false;
      }
    };
    if (_isDomSupported()) {
      window.addEventListener("test", null, options);
      window.removeEventListener("test", null, options);
    }
  } catch (e2) {
  }
  return passiveSupported;
})();
function readUsedSize(element, property) {
  const value = getStyle(element, property);
  const matches = value && value.match(/^(\d+)(\.\d+)?px$/);
  return matches ? +matches[1] : void 0;
}
var getRightToLeftAdapter = function(rectX, width) {
  return {
    x(x2) {
      return rectX + rectX + width - x2;
    },
    setWidth(w2) {
      width = w2;
    },
    textAlign(align) {
      if (align === "center") {
        return align;
      }
      return align === "right" ? "left" : "right";
    },
    xPlus(x2, value) {
      return x2 - value;
    },
    leftForLtr(x2, itemWidth) {
      return x2 - itemWidth;
    }
  };
};
var getLeftToRightAdapter = function() {
  return {
    x(x2) {
      return x2;
    },
    setWidth(w2) {
    },
    textAlign(align) {
      return align;
    },
    xPlus(x2, value) {
      return x2 + value;
    },
    leftForLtr(x2, _itemWidth) {
      return x2;
    }
  };
};
function getRtlAdapter(rtl, rectX, width) {
  return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();
}
function overrideTextDirection(ctx, direction) {
  let style, original;
  if (direction === "ltr" || direction === "rtl") {
    style = ctx.canvas.style;
    original = [
      style.getPropertyValue("direction"),
      style.getPropertyPriority("direction")
    ];
    style.setProperty("direction", direction, "important");
    ctx.prevTextDirection = original;
  }
}
function restoreTextDirection(ctx, original) {
  if (original !== void 0) {
    delete ctx.prevTextDirection;
    ctx.canvas.style.setProperty("direction", original[0], original[1]);
  }
}
function getSizeForArea(scale, chartArea, field) {
  return scale.options.clip ? scale[field] : chartArea[field];
}
function getDatasetArea(meta, chartArea) {
  const { xScale, yScale } = meta;
  if (xScale && yScale) {
    return {
      left: getSizeForArea(xScale, chartArea, "left"),
      right: getSizeForArea(xScale, chartArea, "right"),
      top: getSizeForArea(yScale, chartArea, "top"),
      bottom: getSizeForArea(yScale, chartArea, "bottom")
    };
  }
  return chartArea;
}
function getDatasetClipArea(chart, meta) {
  const clip = meta._clip;
  if (clip.disabled) {
    return false;
  }
  const area = getDatasetArea(meta, chart.chartArea);
  return {
    left: clip.left === false ? 0 : area.left - (clip.left === true ? 0 : clip.left),
    right: clip.right === false ? chart.width : area.right + (clip.right === true ? 0 : clip.right),
    top: clip.top === false ? 0 : area.top - (clip.top === true ? 0 : clip.top),
    bottom: clip.bottom === false ? chart.height : area.bottom + (clip.bottom === true ? 0 : clip.bottom)
  };
}

// node_modules/.pnpm/chart.js@4.5.1/node_modules/chart.js/dist/chart.js
var Animator = class {
  constructor() {
    this._request = null;
    this._charts = /* @__PURE__ */ new Map();
    this._running = false;
    this._lastDate = void 0;
  }
  _notify(chart, anims, date, type) {
    const callbacks = anims.listeners[type];
    const numSteps = anims.duration;
    callbacks.forEach((fn2) => fn2({
      chart,
      initial: anims.initial,
      numSteps,
      currentStep: Math.min(date - anims.start, numSteps)
    }));
  }
  _refresh() {
    if (this._request) {
      return;
    }
    this._running = true;
    this._request = requestAnimFrame.call(window, () => {
      this._update();
      this._request = null;
      if (this._running) {
        this._refresh();
      }
    });
  }
  _update(date = Date.now()) {
    let remaining = 0;
    this._charts.forEach((anims, chart) => {
      if (!anims.running || !anims.items.length) {
        return;
      }
      const items = anims.items;
      let i2 = items.length - 1;
      let draw = false;
      let item;
      for (; i2 >= 0; --i2) {
        item = items[i2];
        if (item._active) {
          if (item._total > anims.duration) {
            anims.duration = item._total;
          }
          item.tick(date);
          draw = true;
        } else {
          items[i2] = items[items.length - 1];
          items.pop();
        }
      }
      if (draw) {
        chart.draw();
        this._notify(chart, anims, date, "progress");
      }
      if (!items.length) {
        anims.running = false;
        this._notify(chart, anims, date, "complete");
        anims.initial = false;
      }
      remaining += items.length;
    });
    this._lastDate = date;
    if (remaining === 0) {
      this._running = false;
    }
  }
  _getAnims(chart) {
    const charts = this._charts;
    let anims = charts.get(chart);
    if (!anims) {
      anims = {
        running: false,
        initial: true,
        items: [],
        listeners: {
          complete: [],
          progress: []
        }
      };
      charts.set(chart, anims);
    }
    return anims;
  }
  listen(chart, event, cb) {
    this._getAnims(chart).listeners[event].push(cb);
  }
  add(chart, items) {
    if (!items || !items.length) {
      return;
    }
    this._getAnims(chart).items.push(...items);
  }
  has(chart) {
    return this._getAnims(chart).items.length > 0;
  }
  start(chart) {
    const anims = this._charts.get(chart);
    if (!anims) {
      return;
    }
    anims.running = true;
    anims.start = Date.now();
    anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);
    this._refresh();
  }
  running(chart) {
    if (!this._running) {
      return false;
    }
    const anims = this._charts.get(chart);
    if (!anims || !anims.running || !anims.items.length) {
      return false;
    }
    return true;
  }
  stop(chart) {
    const anims = this._charts.get(chart);
    if (!anims || !anims.items.length) {
      return;
    }
    const items = anims.items;
    let i2 = items.length - 1;
    for (; i2 >= 0; --i2) {
      items[i2].cancel();
    }
    anims.items = [];
    this._notify(chart, anims, Date.now(), "complete");
  }
  remove(chart) {
    return this._charts.delete(chart);
  }
};
var animator = /* @__PURE__ */ new Animator();
var transparent = "transparent";
var interpolators = {
  boolean(from2, to2, factor) {
    return factor > 0.5 ? to2 : from2;
  },
  color(from2, to2, factor) {
    const c0 = color(from2 || transparent);
    const c1 = c0.valid && color(to2 || transparent);
    return c1 && c1.valid ? c1.mix(c0, factor).hexString() : to2;
  },
  number(from2, to2, factor) {
    return from2 + (to2 - from2) * factor;
  }
};
var Animation = class {
  constructor(cfg, target, prop, to2) {
    const currentValue = target[prop];
    to2 = resolve([
      cfg.to,
      to2,
      currentValue,
      cfg.from
    ]);
    const from2 = resolve([
      cfg.from,
      currentValue,
      to2
    ]);
    this._active = true;
    this._fn = cfg.fn || interpolators[cfg.type || typeof from2];
    this._easing = effects[cfg.easing] || effects.linear;
    this._start = Math.floor(Date.now() + (cfg.delay || 0));
    this._duration = this._total = Math.floor(cfg.duration);
    this._loop = !!cfg.loop;
    this._target = target;
    this._prop = prop;
    this._from = from2;
    this._to = to2;
    this._promises = void 0;
  }
  active() {
    return this._active;
  }
  update(cfg, to2, date) {
    if (this._active) {
      this._notify(false);
      const currentValue = this._target[this._prop];
      const elapsed = date - this._start;
      const remain = this._duration - elapsed;
      this._start = date;
      this._duration = Math.floor(Math.max(remain, cfg.duration));
      this._total += elapsed;
      this._loop = !!cfg.loop;
      this._to = resolve([
        cfg.to,
        to2,
        currentValue,
        cfg.from
      ]);
      this._from = resolve([
        cfg.from,
        currentValue,
        to2
      ]);
    }
  }
  cancel() {
    if (this._active) {
      this.tick(Date.now());
      this._active = false;
      this._notify(false);
    }
  }
  tick(date) {
    const elapsed = date - this._start;
    const duration = this._duration;
    const prop = this._prop;
    const from2 = this._from;
    const loop = this._loop;
    const to2 = this._to;
    let factor;
    this._active = from2 !== to2 && (loop || elapsed < duration);
    if (!this._active) {
      this._target[prop] = to2;
      this._notify(true);
      return;
    }
    if (elapsed < 0) {
      this._target[prop] = from2;
      return;
    }
    factor = elapsed / duration % 2;
    factor = loop && factor > 1 ? 2 - factor : factor;
    factor = this._easing(Math.min(1, Math.max(0, factor)));
    this._target[prop] = this._fn(from2, to2, factor);
  }
  wait() {
    const promises = this._promises || (this._promises = []);
    return new Promise((res, rej) => {
      promises.push({
        res,
        rej
      });
    });
  }
  _notify(resolved) {
    const method = resolved ? "res" : "rej";
    const promises = this._promises || [];
    for (let i2 = 0; i2 < promises.length; i2++) {
      promises[i2][method]();
    }
  }
};
var Animations = class {
  constructor(chart, config) {
    this._chart = chart;
    this._properties = /* @__PURE__ */ new Map();
    this.configure(config);
  }
  configure(config) {
    if (!isObject(config)) {
      return;
    }
    const animationOptions = Object.keys(defaults2.animation);
    const animatedProps = this._properties;
    Object.getOwnPropertyNames(config).forEach((key) => {
      const cfg = config[key];
      if (!isObject(cfg)) {
        return;
      }
      const resolved = {};
      for (const option of animationOptions) {
        resolved[option] = cfg[option];
      }
      (isArray(cfg.properties) && cfg.properties || [
        key
      ]).forEach((prop) => {
        if (prop === key || !animatedProps.has(prop)) {
          animatedProps.set(prop, resolved);
        }
      });
    });
  }
  _animateOptions(target, values) {
    const newOptions = values.options;
    const options = resolveTargetOptions(target, newOptions);
    if (!options) {
      return [];
    }
    const animations = this._createAnimations(options, newOptions);
    if (newOptions.$shared) {
      awaitAll(target.options.$animations, newOptions).then(() => {
        target.options = newOptions;
      }, () => {
      });
    }
    return animations;
  }
  _createAnimations(target, values) {
    const animatedProps = this._properties;
    const animations = [];
    const running = target.$animations || (target.$animations = {});
    const props = Object.keys(values);
    const date = Date.now();
    let i2;
    for (i2 = props.length - 1; i2 >= 0; --i2) {
      const prop = props[i2];
      if (prop.charAt(0) === "$") {
        continue;
      }
      if (prop === "options") {
        animations.push(...this._animateOptions(target, values));
        continue;
      }
      const value = values[prop];
      let animation = running[prop];
      const cfg = animatedProps.get(prop);
      if (animation) {
        if (cfg && animation.active()) {
          animation.update(cfg, value, date);
          continue;
        } else {
          animation.cancel();
        }
      }
      if (!cfg || !cfg.duration) {
        target[prop] = value;
        continue;
      }
      running[prop] = animation = new Animation(cfg, target, prop, value);
      animations.push(animation);
    }
    return animations;
  }
  update(target, values) {
    if (this._properties.size === 0) {
      Object.assign(target, values);
      return;
    }
    const animations = this._createAnimations(target, values);
    if (animations.length) {
      animator.add(this._chart, animations);
      return true;
    }
  }
};
function awaitAll(animations, properties) {
  const running = [];
  const keys = Object.keys(properties);
  for (let i2 = 0; i2 < keys.length; i2++) {
    const anim = animations[keys[i2]];
    if (anim && anim.active()) {
      running.push(anim.wait());
    }
  }
  return Promise.all(running);
}
function resolveTargetOptions(target, newOptions) {
  if (!newOptions) {
    return;
  }
  let options = target.options;
  if (!options) {
    target.options = newOptions;
    return;
  }
  if (options.$shared) {
    target.options = options = Object.assign({}, options, {
      $shared: false,
      $animations: {}
    });
  }
  return options;
}
function scaleClip(scale, allowedOverflow) {
  const opts = scale && scale.options || {};
  const reverse = opts.reverse;
  const min = opts.min === void 0 ? allowedOverflow : 0;
  const max = opts.max === void 0 ? allowedOverflow : 0;
  return {
    start: reverse ? max : min,
    end: reverse ? min : max
  };
}
function defaultClip(xScale, yScale, allowedOverflow) {
  if (allowedOverflow === false) {
    return false;
  }
  const x2 = scaleClip(xScale, allowedOverflow);
  const y2 = scaleClip(yScale, allowedOverflow);
  return {
    top: y2.end,
    right: x2.end,
    bottom: y2.start,
    left: x2.start
  };
}
function toClip(value) {
  let t3, r2, b2, l2;
  if (isObject(value)) {
    t3 = value.top;
    r2 = value.right;
    b2 = value.bottom;
    l2 = value.left;
  } else {
    t3 = r2 = b2 = l2 = value;
  }
  return {
    top: t3,
    right: r2,
    bottom: b2,
    left: l2,
    disabled: value === false
  };
}
function getSortedDatasetIndices(chart, filterVisible) {
  const keys = [];
  const metasets = chart._getSortedDatasetMetas(filterVisible);
  let i2, ilen;
  for (i2 = 0, ilen = metasets.length; i2 < ilen; ++i2) {
    keys.push(metasets[i2].index);
  }
  return keys;
}
function applyStack(stack, value, dsIndex, options = {}) {
  const keys = stack.keys;
  const singleMode = options.mode === "single";
  let i2, ilen, datasetIndex, otherValue;
  if (value === null) {
    return;
  }
  let found = false;
  for (i2 = 0, ilen = keys.length; i2 < ilen; ++i2) {
    datasetIndex = +keys[i2];
    if (datasetIndex === dsIndex) {
      found = true;
      if (options.all) {
        continue;
      }
      break;
    }
    otherValue = stack.values[datasetIndex];
    if (isNumberFinite(otherValue) && (singleMode || value === 0 || sign(value) === sign(otherValue))) {
      value += otherValue;
    }
  }
  if (!found && !options.all) {
    return 0;
  }
  return value;
}
function convertObjectDataToArray(data, meta) {
  const { iScale, vScale } = meta;
  const iAxisKey = iScale.axis === "x" ? "x" : "y";
  const vAxisKey = vScale.axis === "x" ? "x" : "y";
  const keys = Object.keys(data);
  const adata = new Array(keys.length);
  let i2, ilen, key;
  for (i2 = 0, ilen = keys.length; i2 < ilen; ++i2) {
    key = keys[i2];
    adata[i2] = {
      [iAxisKey]: key,
      [vAxisKey]: data[key]
    };
  }
  return adata;
}
function isStacked(scale, meta) {
  const stacked = scale && scale.options.stacked;
  return stacked || stacked === void 0 && meta.stack !== void 0;
}
function getStackKey(indexScale, valueScale, meta) {
  return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;
}
function getUserBounds(scale) {
  const { min, max, minDefined, maxDefined } = scale.getUserBounds();
  return {
    min: minDefined ? min : Number.NEGATIVE_INFINITY,
    max: maxDefined ? max : Number.POSITIVE_INFINITY
  };
}
function getOrCreateStack(stacks, stackKey, indexValue) {
  const subStack = stacks[stackKey] || (stacks[stackKey] = {});
  return subStack[indexValue] || (subStack[indexValue] = {});
}
function getLastIndexInStack(stack, vScale, positive, type) {
  for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {
    const value = stack[meta.index];
    if (positive && value > 0 || !positive && value < 0) {
      return meta.index;
    }
  }
  return null;
}
function updateStacks(controller, parsed) {
  const { chart, _cachedMeta: meta } = controller;
  const stacks = chart._stacks || (chart._stacks = {});
  const { iScale, vScale, index: datasetIndex } = meta;
  const iAxis = iScale.axis;
  const vAxis = vScale.axis;
  const key = getStackKey(iScale, vScale, meta);
  const ilen = parsed.length;
  let stack;
  for (let i2 = 0; i2 < ilen; ++i2) {
    const item = parsed[i2];
    const { [iAxis]: index, [vAxis]: value } = item;
    const itemStacks = item._stacks || (item._stacks = {});
    stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);
    stack[datasetIndex] = value;
    stack._top = getLastIndexInStack(stack, vScale, true, meta.type);
    stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);
    const visualValues = stack._visualValues || (stack._visualValues = {});
    visualValues[datasetIndex] = value;
  }
}
function getFirstScaleId(chart, axis) {
  const scales = chart.scales;
  return Object.keys(scales).filter((key) => scales[key].axis === axis).shift();
}
function createDatasetContext(parent, index) {
  return createContext(parent, {
    active: false,
    dataset: void 0,
    datasetIndex: index,
    index,
    mode: "default",
    type: "dataset"
  });
}
function createDataContext(parent, index, element) {
  return createContext(parent, {
    active: false,
    dataIndex: index,
    parsed: void 0,
    raw: void 0,
    element,
    index,
    mode: "default",
    type: "data"
  });
}
function clearStacks(meta, items) {
  const datasetIndex = meta.controller.index;
  const axis = meta.vScale && meta.vScale.axis;
  if (!axis) {
    return;
  }
  items = items || meta._parsed;
  for (const parsed of items) {
    const stacks = parsed._stacks;
    if (!stacks || stacks[axis] === void 0 || stacks[axis][datasetIndex] === void 0) {
      return;
    }
    delete stacks[axis][datasetIndex];
    if (stacks[axis]._visualValues !== void 0 && stacks[axis]._visualValues[datasetIndex] !== void 0) {
      delete stacks[axis]._visualValues[datasetIndex];
    }
  }
}
var isDirectUpdateMode = (mode) => mode === "reset" || mode === "none";
var cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);
var createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked && {
  keys: getSortedDatasetIndices(chart, true),
  values: null
};
var DatasetController = class {
  constructor(chart, datasetIndex) {
    this.chart = chart;
    this._ctx = chart.ctx;
    this.index = datasetIndex;
    this._cachedDataOpts = {};
    this._cachedMeta = this.getMeta();
    this._type = this._cachedMeta.type;
    this.options = void 0;
    this._parsing = false;
    this._data = void 0;
    this._objectData = void 0;
    this._sharedOptions = void 0;
    this._drawStart = void 0;
    this._drawCount = void 0;
    this.enableOptionSharing = false;
    this.supportsDecimation = false;
    this.$context = void 0;
    this._syncList = [];
    this.datasetElementType = new.target.datasetElementType;
    this.dataElementType = new.target.dataElementType;
    this.initialize();
  }
  initialize() {
    const meta = this._cachedMeta;
    this.configure();
    this.linkScales();
    meta._stacked = isStacked(meta.vScale, meta);
    this.addElements();
    if (this.options.fill && !this.chart.isPluginEnabled("filler")) {
      console.warn("Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options");
    }
  }
  updateIndex(datasetIndex) {
    if (this.index !== datasetIndex) {
      clearStacks(this._cachedMeta);
    }
    this.index = datasetIndex;
  }
  linkScales() {
    const chart = this.chart;
    const meta = this._cachedMeta;
    const dataset = this.getDataset();
    const chooseId = (axis, x2, y2, r2) => axis === "x" ? x2 : axis === "r" ? r2 : y2;
    const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, "x"));
    const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, "y"));
    const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, "r"));
    const indexAxis = meta.indexAxis;
    const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);
    const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);
    meta.xScale = this.getScaleForId(xid);
    meta.yScale = this.getScaleForId(yid);
    meta.rScale = this.getScaleForId(rid);
    meta.iScale = this.getScaleForId(iid);
    meta.vScale = this.getScaleForId(vid);
  }
  getDataset() {
    return this.chart.data.datasets[this.index];
  }
  getMeta() {
    return this.chart.getDatasetMeta(this.index);
  }
  getScaleForId(scaleID) {
    return this.chart.scales[scaleID];
  }
  _getOtherScale(scale) {
    const meta = this._cachedMeta;
    return scale === meta.iScale ? meta.vScale : meta.iScale;
  }
  reset() {
    this._update("reset");
  }
  _destroy() {
    const meta = this._cachedMeta;
    if (this._data) {
      unlistenArrayEvents(this._data, this);
    }
    if (meta._stacked) {
      clearStacks(meta);
    }
  }
  _dataCheck() {
    const dataset = this.getDataset();
    const data = dataset.data || (dataset.data = []);
    const _data = this._data;
    if (isObject(data)) {
      const meta = this._cachedMeta;
      this._data = convertObjectDataToArray(data, meta);
    } else if (_data !== data) {
      if (_data) {
        unlistenArrayEvents(_data, this);
        const meta = this._cachedMeta;
        clearStacks(meta);
        meta._parsed = [];
      }
      if (data && Object.isExtensible(data)) {
        listenArrayEvents(data, this);
      }
      this._syncList = [];
      this._data = data;
    }
  }
  addElements() {
    const meta = this._cachedMeta;
    this._dataCheck();
    if (this.datasetElementType) {
      meta.dataset = new this.datasetElementType();
    }
  }
  buildOrUpdateElements(resetNewElements) {
    const meta = this._cachedMeta;
    const dataset = this.getDataset();
    let stackChanged = false;
    this._dataCheck();
    const oldStacked = meta._stacked;
    meta._stacked = isStacked(meta.vScale, meta);
    if (meta.stack !== dataset.stack) {
      stackChanged = true;
      clearStacks(meta);
      meta.stack = dataset.stack;
    }
    this._resyncElements(resetNewElements);
    if (stackChanged || oldStacked !== meta._stacked) {
      updateStacks(this, meta._parsed);
      meta._stacked = isStacked(meta.vScale, meta);
    }
  }
  configure() {
    const config = this.chart.config;
    const scopeKeys = config.datasetScopeKeys(this._type);
    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
    this.options = config.createResolver(scopes, this.getContext());
    this._parsing = this.options.parsing;
    this._cachedDataOpts = {};
  }
  parse(start, count) {
    const { _cachedMeta: meta, _data: data } = this;
    const { iScale, _stacked } = meta;
    const iAxis = iScale.axis;
    let sorted = start === 0 && count === data.length ? true : meta._sorted;
    let prev = start > 0 && meta._parsed[start - 1];
    let i2, cur, parsed;
    if (this._parsing === false) {
      meta._parsed = data;
      meta._sorted = true;
      parsed = data;
    } else {
      if (isArray(data[start])) {
        parsed = this.parseArrayData(meta, data, start, count);
      } else if (isObject(data[start])) {
        parsed = this.parseObjectData(meta, data, start, count);
      } else {
        parsed = this.parsePrimitiveData(meta, data, start, count);
      }
      const isNotInOrderComparedToPrev = () => cur[iAxis] === null || prev && cur[iAxis] < prev[iAxis];
      for (i2 = 0; i2 < count; ++i2) {
        meta._parsed[i2 + start] = cur = parsed[i2];
        if (sorted) {
          if (isNotInOrderComparedToPrev()) {
            sorted = false;
          }
          prev = cur;
        }
      }
      meta._sorted = sorted;
    }
    if (_stacked) {
      updateStacks(this, parsed);
    }
  }
  parsePrimitiveData(meta, data, start, count) {
    const { iScale, vScale } = meta;
    const iAxis = iScale.axis;
    const vAxis = vScale.axis;
    const labels = iScale.getLabels();
    const singleScale = iScale === vScale;
    const parsed = new Array(count);
    let i2, ilen, index;
    for (i2 = 0, ilen = count; i2 < ilen; ++i2) {
      index = i2 + start;
      parsed[i2] = {
        [iAxis]: singleScale || iScale.parse(labels[index], index),
        [vAxis]: vScale.parse(data[index], index)
      };
    }
    return parsed;
  }
  parseArrayData(meta, data, start, count) {
    const { xScale, yScale } = meta;
    const parsed = new Array(count);
    let i2, ilen, index, item;
    for (i2 = 0, ilen = count; i2 < ilen; ++i2) {
      index = i2 + start;
      item = data[index];
      parsed[i2] = {
        x: xScale.parse(item[0], index),
        y: yScale.parse(item[1], index)
      };
    }
    return parsed;
  }
  parseObjectData(meta, data, start, count) {
    const { xScale, yScale } = meta;
    const { xAxisKey = "x", yAxisKey = "y" } = this._parsing;
    const parsed = new Array(count);
    let i2, ilen, index, item;
    for (i2 = 0, ilen = count; i2 < ilen; ++i2) {
      index = i2 + start;
      item = data[index];
      parsed[i2] = {
        x: xScale.parse(resolveObjectKey(item, xAxisKey), index),
        y: yScale.parse(resolveObjectKey(item, yAxisKey), index)
      };
    }
    return parsed;
  }
  getParsed(index) {
    return this._cachedMeta._parsed[index];
  }
  getDataElement(index) {
    return this._cachedMeta.data[index];
  }
  applyStack(scale, parsed, mode) {
    const chart = this.chart;
    const meta = this._cachedMeta;
    const value = parsed[scale.axis];
    const stack = {
      keys: getSortedDatasetIndices(chart, true),
      values: parsed._stacks[scale.axis]._visualValues
    };
    return applyStack(stack, value, meta.index, {
      mode
    });
  }
  updateRangeFromParsed(range2, scale, parsed, stack) {
    const parsedValue = parsed[scale.axis];
    let value = parsedValue === null ? NaN : parsedValue;
    const values = stack && parsed._stacks[scale.axis];
    if (stack && values) {
      stack.values = values;
      value = applyStack(stack, parsedValue, this._cachedMeta.index);
    }
    range2.min = Math.min(range2.min, value);
    range2.max = Math.max(range2.max, value);
  }
  getMinMax(scale, canStack) {
    const meta = this._cachedMeta;
    const _parsed = meta._parsed;
    const sorted = meta._sorted && scale === meta.iScale;
    const ilen = _parsed.length;
    const otherScale = this._getOtherScale(scale);
    const stack = createStack(canStack, meta, this.chart);
    const range2 = {
      min: Number.POSITIVE_INFINITY,
      max: Number.NEGATIVE_INFINITY
    };
    const { min: otherMin, max: otherMax } = getUserBounds(otherScale);
    let i2, parsed;
    function _skip() {
      parsed = _parsed[i2];
      const otherValue = parsed[otherScale.axis];
      return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;
    }
    for (i2 = 0; i2 < ilen; ++i2) {
      if (_skip()) {
        continue;
      }
      this.updateRangeFromParsed(range2, scale, parsed, stack);
      if (sorted) {
        break;
      }
    }
    if (sorted) {
      for (i2 = ilen - 1; i2 >= 0; --i2) {
        if (_skip()) {
          continue;
        }
        this.updateRangeFromParsed(range2, scale, parsed, stack);
        break;
      }
    }
    return range2;
  }
  getAllParsedValues(scale) {
    const parsed = this._cachedMeta._parsed;
    const values = [];
    let i2, ilen, value;
    for (i2 = 0, ilen = parsed.length; i2 < ilen; ++i2) {
      value = parsed[i2][scale.axis];
      if (isNumberFinite(value)) {
        values.push(value);
      }
    }
    return values;
  }
  getMaxOverflow() {
    return false;
  }
  getLabelAndValue(index) {
    const meta = this._cachedMeta;
    const iScale = meta.iScale;
    const vScale = meta.vScale;
    const parsed = this.getParsed(index);
    return {
      label: iScale ? "" + iScale.getLabelForValue(parsed[iScale.axis]) : "",
      value: vScale ? "" + vScale.getLabelForValue(parsed[vScale.axis]) : ""
    };
  }
  _update(mode) {
    const meta = this._cachedMeta;
    this.update(mode || "default");
    meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));
  }
  update(mode) {
  }
  draw() {
    const ctx = this._ctx;
    const chart = this.chart;
    const meta = this._cachedMeta;
    const elements = meta.data || [];
    const area = chart.chartArea;
    const active = [];
    const start = this._drawStart || 0;
    const count = this._drawCount || elements.length - start;
    const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;
    let i2;
    if (meta.dataset) {
      meta.dataset.draw(ctx, area, start, count);
    }
    for (i2 = start; i2 < start + count; ++i2) {
      const element = elements[i2];
      if (element.hidden) {
        continue;
      }
      if (element.active && drawActiveElementsOnTop) {
        active.push(element);
      } else {
        element.draw(ctx, area);
      }
    }
    for (i2 = 0; i2 < active.length; ++i2) {
      active[i2].draw(ctx, area);
    }
  }
  getStyle(index, active) {
    const mode = active ? "active" : "default";
    return index === void 0 && this._cachedMeta.dataset ? this.resolveDatasetElementOptions(mode) : this.resolveDataElementOptions(index || 0, mode);
  }
  getContext(index, active, mode) {
    const dataset = this.getDataset();
    let context;
    if (index >= 0 && index < this._cachedMeta.data.length) {
      const element = this._cachedMeta.data[index];
      context = element.$context || (element.$context = createDataContext(this.getContext(), index, element));
      context.parsed = this.getParsed(index);
      context.raw = dataset.data[index];
      context.index = context.dataIndex = index;
    } else {
      context = this.$context || (this.$context = createDatasetContext(this.chart.getContext(), this.index));
      context.dataset = dataset;
      context.index = context.datasetIndex = this.index;
    }
    context.active = !!active;
    context.mode = mode;
    return context;
  }
  resolveDatasetElementOptions(mode) {
    return this._resolveElementOptions(this.datasetElementType.id, mode);
  }
  resolveDataElementOptions(index, mode) {
    return this._resolveElementOptions(this.dataElementType.id, mode, index);
  }
  _resolveElementOptions(elementType, mode = "default", index) {
    const active = mode === "active";
    const cache = this._cachedDataOpts;
    const cacheKey = elementType + "-" + mode;
    const cached = cache[cacheKey];
    const sharing = this.enableOptionSharing && defined(index);
    if (cached) {
      return cloneIfNotShared(cached, sharing);
    }
    const config = this.chart.config;
    const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);
    const prefixes = active ? [
      `${elementType}Hover`,
      "hover",
      elementType,
      ""
    ] : [
      elementType,
      ""
    ];
    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
    const names2 = Object.keys(defaults2.elements[elementType]);
    const context = () => this.getContext(index, active, mode);
    const values = config.resolveNamedOptions(scopes, names2, context, prefixes);
    if (values.$shared) {
      values.$shared = sharing;
      cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));
    }
    return values;
  }
  _resolveAnimations(index, transition, active) {
    const chart = this.chart;
    const cache = this._cachedDataOpts;
    const cacheKey = `animation-${transition}`;
    const cached = cache[cacheKey];
    if (cached) {
      return cached;
    }
    let options;
    if (chart.options.animation !== false) {
      const config = this.chart.config;
      const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);
      const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
      options = config.createResolver(scopes, this.getContext(index, active, transition));
    }
    const animations = new Animations(chart, options && options.animations);
    if (options && options._cacheable) {
      cache[cacheKey] = Object.freeze(animations);
    }
    return animations;
  }
  getSharedOptions(options) {
    if (!options.$shared) {
      return;
    }
    return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));
  }
  includeOptions(mode, sharedOptions) {
    return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;
  }
  _getSharedOptions(start, mode) {
    const firstOpts = this.resolveDataElementOptions(start, mode);
    const previouslySharedOptions = this._sharedOptions;
    const sharedOptions = this.getSharedOptions(firstOpts);
    const includeOptions = this.includeOptions(mode, sharedOptions) || sharedOptions !== previouslySharedOptions;
    this.updateSharedOptions(sharedOptions, mode, firstOpts);
    return {
      sharedOptions,
      includeOptions
    };
  }
  updateElement(element, index, properties, mode) {
    if (isDirectUpdateMode(mode)) {
      Object.assign(element, properties);
    } else {
      this._resolveAnimations(index, mode).update(element, properties);
    }
  }
  updateSharedOptions(sharedOptions, mode, newOptions) {
    if (sharedOptions && !isDirectUpdateMode(mode)) {
      this._resolveAnimations(void 0, mode).update(sharedOptions, newOptions);
    }
  }
  _setStyle(element, index, mode, active) {
    element.active = active;
    const options = this.getStyle(index, active);
    this._resolveAnimations(index, mode, active).update(element, {
      options: !active && this.getSharedOptions(options) || options
    });
  }
  removeHoverStyle(element, datasetIndex, index) {
    this._setStyle(element, index, "active", false);
  }
  setHoverStyle(element, datasetIndex, index) {
    this._setStyle(element, index, "active", true);
  }
  _removeDatasetHoverStyle() {
    const element = this._cachedMeta.dataset;
    if (element) {
      this._setStyle(element, void 0, "active", false);
    }
  }
  _setDatasetHoverStyle() {
    const element = this._cachedMeta.dataset;
    if (element) {
      this._setStyle(element, void 0, "active", true);
    }
  }
  _resyncElements(resetNewElements) {
    const data = this._data;
    const elements = this._cachedMeta.data;
    for (const [method, arg1, arg2] of this._syncList) {
      this[method](arg1, arg2);
    }
    this._syncList = [];
    const numMeta = elements.length;
    const numData = data.length;
    const count = Math.min(numData, numMeta);
    if (count) {
      this.parse(0, count);
    }
    if (numData > numMeta) {
      this._insertElements(numMeta, numData - numMeta, resetNewElements);
    } else if (numData < numMeta) {
      this._removeElements(numData, numMeta - numData);
    }
  }
  _insertElements(start, count, resetNewElements = true) {
    const meta = this._cachedMeta;
    const data = meta.data;
    const end = start + count;
    let i2;
    const move = (arr) => {
      arr.length += count;
      for (i2 = arr.length - 1; i2 >= end; i2--) {
        arr[i2] = arr[i2 - count];
      }
    };
    move(data);
    for (i2 = start; i2 < end; ++i2) {
      data[i2] = new this.dataElementType();
    }
    if (this._parsing) {
      move(meta._parsed);
    }
    this.parse(start, count);
    if (resetNewElements) {
      this.updateElements(data, start, count, "reset");
    }
  }
  updateElements(element, start, count, mode) {
  }
  _removeElements(start, count) {
    const meta = this._cachedMeta;
    if (this._parsing) {
      const removed = meta._parsed.splice(start, count);
      if (meta._stacked) {
        clearStacks(meta, removed);
      }
    }
    meta.data.splice(start, count);
  }
  _sync(args) {
    if (this._parsing) {
      this._syncList.push(args);
    } else {
      const [method, arg1, arg2] = args;
      this[method](arg1, arg2);
    }
    this.chart._dataChanges.push([
      this.index,
      ...args
    ]);
  }
  _onDataPush() {
    const count = arguments.length;
    this._sync([
      "_insertElements",
      this.getDataset().data.length - count,
      count
    ]);
  }
  _onDataPop() {
    this._sync([
      "_removeElements",
      this._cachedMeta.data.length - 1,
      1
    ]);
  }
  _onDataShift() {
    this._sync([
      "_removeElements",
      0,
      1
    ]);
  }
  _onDataSplice(start, count) {
    if (count) {
      this._sync([
        "_removeElements",
        start,
        count
      ]);
    }
    const newCount = arguments.length - 2;
    if (newCount) {
      this._sync([
        "_insertElements",
        start,
        newCount
      ]);
    }
  }
  _onDataUnshift() {
    this._sync([
      "_insertElements",
      0,
      arguments.length
    ]);
  }
};
__publicField(DatasetController, "defaults", {});
__publicField(DatasetController, "datasetElementType", null);
__publicField(DatasetController, "dataElementType", null);
function getAllScaleValues(scale, type) {
  if (!scale._cache.$bar) {
    const visibleMetas = scale.getMatchingVisibleMetas(type);
    let values = [];
    for (let i2 = 0, ilen = visibleMetas.length; i2 < ilen; i2++) {
      values = values.concat(visibleMetas[i2].controller.getAllParsedValues(scale));
    }
    scale._cache.$bar = _arrayUnique(values.sort((a2, b2) => a2 - b2));
  }
  return scale._cache.$bar;
}
function computeMinSampleSize(meta) {
  const scale = meta.iScale;
  const values = getAllScaleValues(scale, meta.type);
  let min = scale._length;
  let i2, ilen, curr, prev;
  const updateMinAndPrev = () => {
    if (curr === 32767 || curr === -32768) {
      return;
    }
    if (defined(prev)) {
      min = Math.min(min, Math.abs(curr - prev) || min);
    }
    prev = curr;
  };
  for (i2 = 0, ilen = values.length; i2 < ilen; ++i2) {
    curr = scale.getPixelForValue(values[i2]);
    updateMinAndPrev();
  }
  prev = void 0;
  for (i2 = 0, ilen = scale.ticks.length; i2 < ilen; ++i2) {
    curr = scale.getPixelForTick(i2);
    updateMinAndPrev();
  }
  return min;
}
function computeFitCategoryTraits(index, ruler, options, stackCount) {
  const thickness = options.barThickness;
  let size, ratio;
  if (isNullOrUndef(thickness)) {
    size = ruler.min * options.categoryPercentage;
    ratio = options.barPercentage;
  } else {
    size = thickness * stackCount;
    ratio = 1;
  }
  return {
    chunk: size / stackCount,
    ratio,
    start: ruler.pixels[index] - size / 2
  };
}
function computeFlexCategoryTraits(index, ruler, options, stackCount) {
  const pixels = ruler.pixels;
  const curr = pixels[index];
  let prev = index > 0 ? pixels[index - 1] : null;
  let next = index < pixels.length - 1 ? pixels[index + 1] : null;
  const percent = options.categoryPercentage;
  if (prev === null) {
    prev = curr - (next === null ? ruler.end - ruler.start : next - curr);
  }
  if (next === null) {
    next = curr + curr - prev;
  }
  const start = curr - (curr - Math.min(prev, next)) / 2 * percent;
  const size = Math.abs(next - prev) / 2 * percent;
  return {
    chunk: size / stackCount,
    ratio: options.barPercentage,
    start
  };
}
function parseFloatBar(entry, item, vScale, i2) {
  const startValue = vScale.parse(entry[0], i2);
  const endValue = vScale.parse(entry[1], i2);
  const min = Math.min(startValue, endValue);
  const max = Math.max(startValue, endValue);
  let barStart = min;
  let barEnd = max;
  if (Math.abs(min) > Math.abs(max)) {
    barStart = max;
    barEnd = min;
  }
  item[vScale.axis] = barEnd;
  item._custom = {
    barStart,
    barEnd,
    start: startValue,
    end: endValue,
    min,
    max
  };
}
function parseValue(entry, item, vScale, i2) {
  if (isArray(entry)) {
    parseFloatBar(entry, item, vScale, i2);
  } else {
    item[vScale.axis] = vScale.parse(entry, i2);
  }
  return item;
}
function parseArrayOrPrimitive(meta, data, start, count) {
  const iScale = meta.iScale;
  const vScale = meta.vScale;
  const labels = iScale.getLabels();
  const singleScale = iScale === vScale;
  const parsed = [];
  let i2, ilen, item, entry;
  for (i2 = start, ilen = start + count; i2 < ilen; ++i2) {
    entry = data[i2];
    item = {};
    item[iScale.axis] = singleScale || iScale.parse(labels[i2], i2);
    parsed.push(parseValue(entry, item, vScale, i2));
  }
  return parsed;
}
function isFloatBar(custom) {
  return custom && custom.barStart !== void 0 && custom.barEnd !== void 0;
}
function barSign(size, vScale, actualBase) {
  if (size !== 0) {
    return sign(size);
  }
  return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);
}
function borderProps(properties) {
  let reverse, start, end, top, bottom;
  if (properties.horizontal) {
    reverse = properties.base > properties.x;
    start = "left";
    end = "right";
  } else {
    reverse = properties.base < properties.y;
    start = "bottom";
    end = "top";
  }
  if (reverse) {
    top = "end";
    bottom = "start";
  } else {
    top = "start";
    bottom = "end";
  }
  return {
    start,
    end,
    reverse,
    top,
    bottom
  };
}
function setBorderSkipped(properties, options, stack, index) {
  let edge = options.borderSkipped;
  const res = {};
  if (!edge) {
    properties.borderSkipped = res;
    return;
  }
  if (edge === true) {
    properties.borderSkipped = {
      top: true,
      right: true,
      bottom: true,
      left: true
    };
    return;
  }
  const { start, end, reverse, top, bottom } = borderProps(properties);
  if (edge === "middle" && stack) {
    properties.enableBorderRadius = true;
    if ((stack._top || 0) === index) {
      edge = top;
    } else if ((stack._bottom || 0) === index) {
      edge = bottom;
    } else {
      res[parseEdge(bottom, start, end, reverse)] = true;
      edge = top;
    }
  }
  res[parseEdge(edge, start, end, reverse)] = true;
  properties.borderSkipped = res;
}
function parseEdge(edge, a2, b2, reverse) {
  if (reverse) {
    edge = swap(edge, a2, b2);
    edge = startEnd(edge, b2, a2);
  } else {
    edge = startEnd(edge, a2, b2);
  }
  return edge;
}
function swap(orig, v1, v2) {
  return orig === v1 ? v2 : orig === v2 ? v1 : orig;
}
function startEnd(v2, start, end) {
  return v2 === "start" ? start : v2 === "end" ? end : v2;
}
function setInflateAmount(properties, { inflateAmount }, ratio) {
  properties.inflateAmount = inflateAmount === "auto" ? ratio === 1 ? 0.33 : 0 : inflateAmount;
}
var BarController = class extends DatasetController {
  parsePrimitiveData(meta, data, start, count) {
    return parseArrayOrPrimitive(meta, data, start, count);
  }
  parseArrayData(meta, data, start, count) {
    return parseArrayOrPrimitive(meta, data, start, count);
  }
  parseObjectData(meta, data, start, count) {
    const { iScale, vScale } = meta;
    const { xAxisKey = "x", yAxisKey = "y" } = this._parsing;
    const iAxisKey = iScale.axis === "x" ? xAxisKey : yAxisKey;
    const vAxisKey = vScale.axis === "x" ? xAxisKey : yAxisKey;
    const parsed = [];
    let i2, ilen, item, obj;
    for (i2 = start, ilen = start + count; i2 < ilen; ++i2) {
      obj = data[i2];
      item = {};
      item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i2);
      parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i2));
    }
    return parsed;
  }
  updateRangeFromParsed(range2, scale, parsed, stack) {
    super.updateRangeFromParsed(range2, scale, parsed, stack);
    const custom = parsed._custom;
    if (custom && scale === this._cachedMeta.vScale) {
      range2.min = Math.min(range2.min, custom.min);
      range2.max = Math.max(range2.max, custom.max);
    }
  }
  getMaxOverflow() {
    return 0;
  }
  getLabelAndValue(index) {
    const meta = this._cachedMeta;
    const { iScale, vScale } = meta;
    const parsed = this.getParsed(index);
    const custom = parsed._custom;
    const value = isFloatBar(custom) ? "[" + custom.start + ", " + custom.end + "]" : "" + vScale.getLabelForValue(parsed[vScale.axis]);
    return {
      label: "" + iScale.getLabelForValue(parsed[iScale.axis]),
      value
    };
  }
  initialize() {
    this.enableOptionSharing = true;
    super.initialize();
    const meta = this._cachedMeta;
    meta.stack = this.getDataset().stack;
  }
  update(mode) {
    const meta = this._cachedMeta;
    this.updateElements(meta.data, 0, meta.data.length, mode);
  }
  updateElements(bars, start, count, mode) {
    const reset2 = mode === "reset";
    const { index, _cachedMeta: { vScale } } = this;
    const base = vScale.getBasePixel();
    const horizontal = vScale.isHorizontal();
    const ruler = this._getRuler();
    const { sharedOptions, includeOptions } = this._getSharedOptions(start, mode);
    for (let i2 = start; i2 < start + count; i2++) {
      const parsed = this.getParsed(i2);
      const vpixels = reset2 || isNullOrUndef(parsed[vScale.axis]) ? {
        base,
        head: base
      } : this._calculateBarValuePixels(i2);
      const ipixels = this._calculateBarIndexPixels(i2, ruler);
      const stack = (parsed._stacks || {})[vScale.axis];
      const properties = {
        horizontal,
        base: vpixels.base,
        enableBorderRadius: !stack || isFloatBar(parsed._custom) || index === stack._top || index === stack._bottom,
        x: horizontal ? vpixels.head : ipixels.center,
        y: horizontal ? ipixels.center : vpixels.head,
        height: horizontal ? ipixels.size : Math.abs(vpixels.size),
        width: horizontal ? Math.abs(vpixels.size) : ipixels.size
      };
      if (includeOptions) {
        properties.options = sharedOptions || this.resolveDataElementOptions(i2, bars[i2].active ? "active" : mode);
      }
      const options = properties.options || bars[i2].options;
      setBorderSkipped(properties, options, stack, index);
      setInflateAmount(properties, options, ruler.ratio);
      this.updateElement(bars[i2], i2, properties, mode);
    }
  }
  _getStacks(last, dataIndex) {
    const { iScale } = this._cachedMeta;
    const metasets = iScale.getMatchingVisibleMetas(this._type).filter((meta) => meta.controller.options.grouped);
    const stacked = iScale.options.stacked;
    const stacks = [];
    const currentParsed = this._cachedMeta.controller.getParsed(dataIndex);
    const iScaleValue = currentParsed && currentParsed[iScale.axis];
    const skipNull = (meta) => {
      const parsed = meta._parsed.find((item) => item[iScale.axis] === iScaleValue);
      const val = parsed && parsed[meta.vScale.axis];
      if (isNullOrUndef(val) || isNaN(val)) {
        return true;
      }
    };
    for (const meta of metasets) {
      if (dataIndex !== void 0 && skipNull(meta)) {
        continue;
      }
      if (stacked === false || stacks.indexOf(meta.stack) === -1 || stacked === void 0 && meta.stack === void 0) {
        stacks.push(meta.stack);
      }
      if (meta.index === last) {
        break;
      }
    }
    if (!stacks.length) {
      stacks.push(void 0);
    }
    return stacks;
  }
  _getStackCount(index) {
    return this._getStacks(void 0, index).length;
  }
  _getAxisCount() {
    return this._getAxis().length;
  }
  getFirstScaleIdForIndexAxis() {
    const scales = this.chart.scales;
    const indexScaleId = this.chart.options.indexAxis;
    return Object.keys(scales).filter((key) => scales[key].axis === indexScaleId).shift();
  }
  _getAxis() {
    const axis = {};
    const firstScaleAxisId = this.getFirstScaleIdForIndexAxis();
    for (const dataset of this.chart.data.datasets) {
      axis[valueOrDefault(this.chart.options.indexAxis === "x" ? dataset.xAxisID : dataset.yAxisID, firstScaleAxisId)] = true;
    }
    return Object.keys(axis);
  }
  _getStackIndex(datasetIndex, name, dataIndex) {
    const stacks = this._getStacks(datasetIndex, dataIndex);
    const index = name !== void 0 ? stacks.indexOf(name) : -1;
    return index === -1 ? stacks.length - 1 : index;
  }
  _getRuler() {
    const opts = this.options;
    const meta = this._cachedMeta;
    const iScale = meta.iScale;
    const pixels = [];
    let i2, ilen;
    for (i2 = 0, ilen = meta.data.length; i2 < ilen; ++i2) {
      pixels.push(iScale.getPixelForValue(this.getParsed(i2)[iScale.axis], i2));
    }
    const barThickness = opts.barThickness;
    const min = barThickness || computeMinSampleSize(meta);
    return {
      min,
      pixels,
      start: iScale._startPixel,
      end: iScale._endPixel,
      stackCount: this._getStackCount(),
      scale: iScale,
      grouped: opts.grouped,
      ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage
    };
  }
  _calculateBarValuePixels(index) {
    const { _cachedMeta: { vScale, _stacked, index: datasetIndex }, options: { base: baseValue, minBarLength } } = this;
    const actualBase = baseValue || 0;
    const parsed = this.getParsed(index);
    const custom = parsed._custom;
    const floating = isFloatBar(custom);
    let value = parsed[vScale.axis];
    let start = 0;
    let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;
    let head, size;
    if (length !== value) {
      start = length - value;
      length = value;
    }
    if (floating) {
      value = custom.barStart;
      length = custom.barEnd - custom.barStart;
      if (value !== 0 && sign(value) !== sign(custom.barEnd)) {
        start = 0;
      }
      start += value;
    }
    const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;
    let base = vScale.getPixelForValue(startValue);
    if (this.chart.getDataVisibility(index)) {
      head = vScale.getPixelForValue(start + length);
    } else {
      head = base;
    }
    size = head - base;
    if (Math.abs(size) < minBarLength) {
      size = barSign(size, vScale, actualBase) * minBarLength;
      if (value === actualBase) {
        base -= size / 2;
      }
      const startPixel = vScale.getPixelForDecimal(0);
      const endPixel = vScale.getPixelForDecimal(1);
      const min = Math.min(startPixel, endPixel);
      const max = Math.max(startPixel, endPixel);
      base = Math.max(Math.min(base, max), min);
      head = base + size;
      if (_stacked && !floating) {
        parsed._stacks[vScale.axis]._visualValues[datasetIndex] = vScale.getValueForPixel(head) - vScale.getValueForPixel(base);
      }
    }
    if (base === vScale.getPixelForValue(actualBase)) {
      const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;
      base += halfGrid;
      size -= halfGrid;
    }
    return {
      size,
      base,
      head,
      center: head + size / 2
    };
  }
  _calculateBarIndexPixels(index, ruler) {
    const scale = ruler.scale;
    const options = this.options;
    const skipNull = options.skipNull;
    const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);
    let center, size;
    const axisCount = this._getAxisCount();
    if (ruler.grouped) {
      const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;
      const range2 = options.barThickness === "flex" ? computeFlexCategoryTraits(index, ruler, options, stackCount * axisCount) : computeFitCategoryTraits(index, ruler, options, stackCount * axisCount);
      const axisID = this.chart.options.indexAxis === "x" ? this.getDataset().xAxisID : this.getDataset().yAxisID;
      const axisNumber = this._getAxis().indexOf(valueOrDefault(axisID, this.getFirstScaleIdForIndexAxis()));
      const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : void 0) + axisNumber;
      center = range2.start + range2.chunk * stackIndex + range2.chunk / 2;
      size = Math.min(maxBarThickness, range2.chunk * range2.ratio);
    } else {
      center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);
      size = Math.min(maxBarThickness, ruler.min * ruler.ratio);
    }
    return {
      base: center - size / 2,
      head: center + size / 2,
      center,
      size
    };
  }
  draw() {
    const meta = this._cachedMeta;
    const vScale = meta.vScale;
    const rects = meta.data;
    const ilen = rects.length;
    let i2 = 0;
    for (; i2 < ilen; ++i2) {
      if (this.getParsed(i2)[vScale.axis] !== null && !rects[i2].hidden) {
        rects[i2].draw(this._ctx);
      }
    }
  }
};
__publicField(BarController, "id", "bar");
__publicField(BarController, "defaults", {
  datasetElementType: false,
  dataElementType: "bar",
  categoryPercentage: 0.8,
  barPercentage: 0.9,
  grouped: true,
  animations: {
    numbers: {
      type: "number",
      properties: [
        "x",
        "y",
        "base",
        "width",
        "height"
      ]
    }
  }
});
__publicField(BarController, "overrides", {
  scales: {
    _index_: {
      type: "category",
      offset: true,
      grid: {
        offset: true
      }
    },
    _value_: {
      type: "linear",
      beginAtZero: true
    }
  }
});
function getRatioAndOffset(rotation, circumference, cutout) {
  let ratioX = 1;
  let ratioY = 1;
  let offsetX = 0;
  let offsetY = 0;
  if (circumference < TAU) {
    const startAngle = rotation;
    const endAngle = startAngle + circumference;
    const startX = Math.cos(startAngle);
    const startY = Math.sin(startAngle);
    const endX = Math.cos(endAngle);
    const endY = Math.sin(endAngle);
    const calcMax = (angle, a2, b2) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a2, a2 * cutout, b2, b2 * cutout);
    const calcMin = (angle, a2, b2) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a2, a2 * cutout, b2, b2 * cutout);
    const maxX = calcMax(0, startX, endX);
    const maxY = calcMax(HALF_PI, startY, endY);
    const minX = calcMin(PI, startX, endX);
    const minY = calcMin(PI + HALF_PI, startY, endY);
    ratioX = (maxX - minX) / 2;
    ratioY = (maxY - minY) / 2;
    offsetX = -(maxX + minX) / 2;
    offsetY = -(maxY + minY) / 2;
  }
  return {
    ratioX,
    ratioY,
    offsetX,
    offsetY
  };
}
var DoughnutController = class extends DatasetController {
  constructor(chart, datasetIndex) {
    super(chart, datasetIndex);
    this.enableOptionSharing = true;
    this.innerRadius = void 0;
    this.outerRadius = void 0;
    this.offsetX = void 0;
    this.offsetY = void 0;
  }
  linkScales() {
  }
  parse(start, count) {
    const data = this.getDataset().data;
    const meta = this._cachedMeta;
    if (this._parsing === false) {
      meta._parsed = data;
    } else {
      let getter = (i3) => +data[i3];
      if (isObject(data[start])) {
        const { key = "value" } = this._parsing;
        getter = (i3) => +resolveObjectKey(data[i3], key);
      }
      let i2, ilen;
      for (i2 = start, ilen = start + count; i2 < ilen; ++i2) {
        meta._parsed[i2] = getter(i2);
      }
    }
  }
  _getRotation() {
    return toRadians(this.options.rotation - 90);
  }
  _getCircumference() {
    return toRadians(this.options.circumference);
  }
  _getRotationExtents() {
    let min = TAU;
    let max = -TAU;
    for (let i2 = 0; i2 < this.chart.data.datasets.length; ++i2) {
      if (this.chart.isDatasetVisible(i2) && this.chart.getDatasetMeta(i2).type === this._type) {
        const controller = this.chart.getDatasetMeta(i2).controller;
        const rotation = controller._getRotation();
        const circumference = controller._getCircumference();
        min = Math.min(min, rotation);
        max = Math.max(max, rotation + circumference);
      }
    }
    return {
      rotation: min,
      circumference: max - min
    };
  }
  update(mode) {
    const chart = this.chart;
    const { chartArea } = chart;
    const meta = this._cachedMeta;
    const arcs = meta.data;
    const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;
    const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);
    const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);
    const chartWeight = this._getRingWeight(this.index);
    const { circumference, rotation } = this._getRotationExtents();
    const { ratioX, ratioY, offsetX, offsetY } = getRatioAndOffset(rotation, circumference, cutout);
    const maxWidth = (chartArea.width - spacing) / ratioX;
    const maxHeight = (chartArea.height - spacing) / ratioY;
    const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);
    const outerRadius = toDimension(this.options.radius, maxRadius);
    const innerRadius = Math.max(outerRadius * cutout, 0);
    const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();
    this.offsetX = offsetX * outerRadius;
    this.offsetY = offsetY * outerRadius;
    meta.total = this.calculateTotal();
    this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);
    this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);
    this.updateElements(arcs, 0, arcs.length, mode);
  }
  _circumference(i2, reset2) {
    const opts = this.options;
    const meta = this._cachedMeta;
    const circumference = this._getCircumference();
    if (reset2 && opts.animation.animateRotate || !this.chart.getDataVisibility(i2) || meta._parsed[i2] === null || meta.data[i2].hidden) {
      return 0;
    }
    return this.calculateCircumference(meta._parsed[i2] * circumference / TAU);
  }
  updateElements(arcs, start, count, mode) {
    const reset2 = mode === "reset";
    const chart = this.chart;
    const chartArea = chart.chartArea;
    const opts = chart.options;
    const animationOpts = opts.animation;
    const centerX = (chartArea.left + chartArea.right) / 2;
    const centerY = (chartArea.top + chartArea.bottom) / 2;
    const animateScale = reset2 && animationOpts.animateScale;
    const innerRadius = animateScale ? 0 : this.innerRadius;
    const outerRadius = animateScale ? 0 : this.outerRadius;
    const { sharedOptions, includeOptions } = this._getSharedOptions(start, mode);
    let startAngle = this._getRotation();
    let i2;
    for (i2 = 0; i2 < start; ++i2) {
      startAngle += this._circumference(i2, reset2);
    }
    for (i2 = start; i2 < start + count; ++i2) {
      const circumference = this._circumference(i2, reset2);
      const arc = arcs[i2];
      const properties = {
        x: centerX + this.offsetX,
        y: centerY + this.offsetY,
        startAngle,
        endAngle: startAngle + circumference,
        circumference,
        outerRadius,
        innerRadius
      };
      if (includeOptions) {
        properties.options = sharedOptions || this.resolveDataElementOptions(i2, arc.active ? "active" : mode);
      }
      startAngle += circumference;
      this.updateElement(arc, i2, properties, mode);
    }
  }
  calculateTotal() {
    const meta = this._cachedMeta;
    const metaData = meta.data;
    let total = 0;
    let i2;
    for (i2 = 0; i2 < metaData.length; i2++) {
      const value = meta._parsed[i2];
      if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i2) && !metaData[i2].hidden) {
        total += Math.abs(value);
      }
    }
    return total;
  }
  calculateCircumference(value) {
    const total = this._cachedMeta.total;
    if (total > 0 && !isNaN(value)) {
      return TAU * (Math.abs(value) / total);
    }
    return 0;
  }
  getLabelAndValue(index) {
    const meta = this._cachedMeta;
    const chart = this.chart;
    const labels = chart.data.labels || [];
    const value = formatNumber(meta._parsed[index], chart.options.locale);
    return {
      label: labels[index] || "",
      value
    };
  }
  getMaxBorderWidth(arcs) {
    let max = 0;
    const chart = this.chart;
    let i2, ilen, meta, controller, options;
    if (!arcs) {
      for (i2 = 0, ilen = chart.data.datasets.length; i2 < ilen; ++i2) {
        if (chart.isDatasetVisible(i2)) {
          meta = chart.getDatasetMeta(i2);
          arcs = meta.data;
          controller = meta.controller;
          break;
        }
      }
    }
    if (!arcs) {
      return 0;
    }
    for (i2 = 0, ilen = arcs.length; i2 < ilen; ++i2) {
      options = controller.resolveDataElementOptions(i2);
      if (options.borderAlign !== "inner") {
        max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);
      }
    }
    return max;
  }
  getMaxOffset(arcs) {
    let max = 0;
    for (let i2 = 0, ilen = arcs.length; i2 < ilen; ++i2) {
      const options = this.resolveDataElementOptions(i2);
      max = Math.max(max, options.offset || 0, options.hoverOffset || 0);
    }
    return max;
  }
  _getRingWeightOffset(datasetIndex) {
    let ringWeightOffset = 0;
    for (let i2 = 0; i2 < datasetIndex; ++i2) {
      if (this.chart.isDatasetVisible(i2)) {
        ringWeightOffset += this._getRingWeight(i2);
      }
    }
    return ringWeightOffset;
  }
  _getRingWeight(datasetIndex) {
    return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);
  }
  _getVisibleDatasetWeightTotal() {
    return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;
  }
};
__publicField(DoughnutController, "id", "doughnut");
__publicField(DoughnutController, "defaults", {
  datasetElementType: false,
  dataElementType: "arc",
  animation: {
    animateRotate: true,
    animateScale: false
  },
  animations: {
    numbers: {
      type: "number",
      properties: [
        "circumference",
        "endAngle",
        "innerRadius",
        "outerRadius",
        "startAngle",
        "x",
        "y",
        "offset",
        "borderWidth",
        "spacing"
      ]
    }
  },
  cutout: "50%",
  rotation: 0,
  circumference: 360,
  radius: "100%",
  spacing: 0,
  indexAxis: "r"
});
__publicField(DoughnutController, "descriptors", {
  _scriptable: (name) => name !== "spacing",
  _indexable: (name) => name !== "spacing" && !name.startsWith("borderDash") && !name.startsWith("hoverBorderDash")
});
__publicField(DoughnutController, "overrides", {
  aspectRatio: 1,
  plugins: {
    legend: {
      labels: {
        generateLabels(chart) {
          const data = chart.data;
          const { labels: { pointStyle, textAlign, color: color2, useBorderRadius, borderRadius } } = chart.legend.options;
          if (data.labels.length && data.datasets.length) {
            return data.labels.map((label, i2) => {
              const meta = chart.getDatasetMeta(0);
              const style = meta.controller.getStyle(i2);
              return {
                text: label,
                fillStyle: style.backgroundColor,
                fontColor: color2,
                hidden: !chart.getDataVisibility(i2),
                lineDash: style.borderDash,
                lineDashOffset: style.borderDashOffset,
                lineJoin: style.borderJoinStyle,
                lineWidth: style.borderWidth,
                strokeStyle: style.borderColor,
                textAlign,
                pointStyle,
                borderRadius: useBorderRadius && (borderRadius || style.borderRadius),
                index: i2
              };
            });
          }
          return [];
        }
      },
      onClick(e2, legendItem, legend) {
        legend.chart.toggleDataVisibility(legendItem.index);
        legend.chart.update();
      }
    }
  }
});
var PieController = class extends DoughnutController {
};
__publicField(PieController, "id", "pie");
__publicField(PieController, "defaults", {
  cutout: 0,
  rotation: 0,
  circumference: 360,
  radius: "100%"
});
function abstract() {
  throw new Error("This method is not implemented: Check that a complete date adapter is provided.");
}
var DateAdapterBase = class _DateAdapterBase {
  constructor(options) {
    __publicField(this, "options");
    this.options = options || {};
  }
  /**
  * Override default date adapter methods.
  * Accepts type parameter to define options type.
  * @example
  * Chart._adapters._date.override<{myAdapterOption: string}>({
  *   init() {
  *     console.log(this.options.myAdapterOption);
  *   }
  * })
  */
  static override(members) {
    Object.assign(_DateAdapterBase.prototype, members);
  }
  // eslint-disable-next-line @typescript-eslint/no-empty-function
  init() {
  }
  formats() {
    return abstract();
  }
  parse() {
    return abstract();
  }
  format() {
    return abstract();
  }
  add() {
    return abstract();
  }
  diff() {
    return abstract();
  }
  startOf() {
    return abstract();
  }
  endOf() {
    return abstract();
  }
};
var adapters = {
  _date: DateAdapterBase
};
function binarySearch(metaset, axis, value, intersect) {
  const { controller, data, _sorted } = metaset;
  const iScale = controller._cachedMeta.iScale;
  const spanGaps = metaset.dataset ? metaset.dataset.options ? metaset.dataset.options.spanGaps : null : null;
  if (iScale && axis === iScale.axis && axis !== "r" && _sorted && data.length) {
    const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;
    if (!intersect) {
      const result = lookupMethod(data, axis, value);
      if (spanGaps) {
        const { vScale } = controller._cachedMeta;
        const { _parsed } = metaset;
        const distanceToDefinedLo = _parsed.slice(0, result.lo + 1).reverse().findIndex((point) => !isNullOrUndef(point[vScale.axis]));
        result.lo -= Math.max(0, distanceToDefinedLo);
        const distanceToDefinedHi = _parsed.slice(result.hi).findIndex((point) => !isNullOrUndef(point[vScale.axis]));
        result.hi += Math.max(0, distanceToDefinedHi);
      }
      return result;
    } else if (controller._sharedOptions) {
      const el = data[0];
      const range2 = typeof el.getRange === "function" && el.getRange(axis);
      if (range2) {
        const start = lookupMethod(data, axis, value - range2);
        const end = lookupMethod(data, axis, value + range2);
        return {
          lo: start.lo,
          hi: end.hi
        };
      }
    }
  }
  return {
    lo: 0,
    hi: data.length - 1
  };
}
function evaluateInteractionItems(chart, axis, position, handler, intersect) {
  const metasets = chart.getSortedVisibleDatasetMetas();
  const value = position[axis];
  for (let i2 = 0, ilen = metasets.length; i2 < ilen; ++i2) {
    const { index, data } = metasets[i2];
    const { lo, hi: hi2 } = binarySearch(metasets[i2], axis, value, intersect);
    for (let j2 = lo; j2 <= hi2; ++j2) {
      const element = data[j2];
      if (!element.skip) {
        handler(element, index, j2);
      }
    }
  }
}
function getDistanceMetricForAxis(axis) {
  const useX = axis.indexOf("x") !== -1;
  const useY = axis.indexOf("y") !== -1;
  return function(pt1, pt22) {
    const deltaX = useX ? Math.abs(pt1.x - pt22.x) : 0;
    const deltaY = useY ? Math.abs(pt1.y - pt22.y) : 0;
    return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
  };
}
function getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {
  const items = [];
  if (!includeInvisible && !chart.isPointInArea(position)) {
    return items;
  }
  const evaluationFunc = function(element, datasetIndex, index) {
    if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {
      return;
    }
    if (element.inRange(position.x, position.y, useFinalPosition)) {
      items.push({
        element,
        datasetIndex,
        index
      });
    }
  };
  evaluateInteractionItems(chart, axis, position, evaluationFunc, true);
  return items;
}
function getNearestRadialItems(chart, position, axis, useFinalPosition) {
  let items = [];
  function evaluationFunc(element, datasetIndex, index) {
    const { startAngle, endAngle } = element.getProps([
      "startAngle",
      "endAngle"
    ], useFinalPosition);
    const { angle } = getAngleFromPoint(element, {
      x: position.x,
      y: position.y
    });
    if (_angleBetween(angle, startAngle, endAngle)) {
      items.push({
        element,
        datasetIndex,
        index
      });
    }
  }
  evaluateInteractionItems(chart, axis, position, evaluationFunc);
  return items;
}
function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
  let items = [];
  const distanceMetric = getDistanceMetricForAxis(axis);
  let minDistance = Number.POSITIVE_INFINITY;
  function evaluationFunc(element, datasetIndex, index) {
    const inRange2 = element.inRange(position.x, position.y, useFinalPosition);
    if (intersect && !inRange2) {
      return;
    }
    const center = element.getCenterPoint(useFinalPosition);
    const pointInArea = !!includeInvisible || chart.isPointInArea(center);
    if (!pointInArea && !inRange2) {
      return;
    }
    const distance = distanceMetric(position, center);
    if (distance < minDistance) {
      items = [
        {
          element,
          datasetIndex,
          index
        }
      ];
      minDistance = distance;
    } else if (distance === minDistance) {
      items.push({
        element,
        datasetIndex,
        index
      });
    }
  }
  evaluateInteractionItems(chart, axis, position, evaluationFunc);
  return items;
}
function getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
  if (!includeInvisible && !chart.isPointInArea(position)) {
    return [];
  }
  return axis === "r" && !intersect ? getNearestRadialItems(chart, position, axis, useFinalPosition) : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);
}
function getAxisItems(chart, position, axis, intersect, useFinalPosition) {
  const items = [];
  const rangeMethod = axis === "x" ? "inXRange" : "inYRange";
  let intersectsItem = false;
  evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {
    if (element[rangeMethod] && element[rangeMethod](position[axis], useFinalPosition)) {
      items.push({
        element,
        datasetIndex,
        index
      });
      intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);
    }
  });
  if (intersect && !intersectsItem) {
    return [];
  }
  return items;
}
var Interaction = {
  evaluateInteractionItems,
  modes: {
    index(chart, e2, options, useFinalPosition) {
      const position = getRelativePosition(e2, chart);
      const axis = options.axis || "x";
      const includeInvisible = options.includeInvisible || false;
      const items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
      const elements = [];
      if (!items.length) {
        return [];
      }
      chart.getSortedVisibleDatasetMetas().forEach((meta) => {
        const index = items[0].index;
        const element = meta.data[index];
        if (element && !element.skip) {
          elements.push({
            element,
            datasetIndex: meta.index,
            index
          });
        }
      });
      return elements;
    },
    dataset(chart, e2, options, useFinalPosition) {
      const position = getRelativePosition(e2, chart);
      const axis = options.axis || "xy";
      const includeInvisible = options.includeInvisible || false;
      let items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
      if (items.length > 0) {
        const datasetIndex = items[0].datasetIndex;
        const data = chart.getDatasetMeta(datasetIndex).data;
        items = [];
        for (let i2 = 0; i2 < data.length; ++i2) {
          items.push({
            element: data[i2],
            datasetIndex,
            index: i2
          });
        }
      }
      return items;
    },
    point(chart, e2, options, useFinalPosition) {
      const position = getRelativePosition(e2, chart);
      const axis = options.axis || "xy";
      const includeInvisible = options.includeInvisible || false;
      return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);
    },
    nearest(chart, e2, options, useFinalPosition) {
      const position = getRelativePosition(e2, chart);
      const axis = options.axis || "xy";
      const includeInvisible = options.includeInvisible || false;
      return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);
    },
    x(chart, e2, options, useFinalPosition) {
      const position = getRelativePosition(e2, chart);
      return getAxisItems(chart, position, "x", options.intersect, useFinalPosition);
    },
    y(chart, e2, options, useFinalPosition) {
      const position = getRelativePosition(e2, chart);
      return getAxisItems(chart, position, "y", options.intersect, useFinalPosition);
    }
  }
};
var STATIC_POSITIONS = [
  "left",
  "top",
  "right",
  "bottom"
];
function filterByPosition(array, position) {
  return array.filter((v2) => v2.pos === position);
}
function filterDynamicPositionByAxis(array, axis) {
  return array.filter((v2) => STATIC_POSITIONS.indexOf(v2.pos) === -1 && v2.box.axis === axis);
}
function sortByWeight(array, reverse) {
  return array.sort((a2, b2) => {
    const v0 = reverse ? b2 : a2;
    const v1 = reverse ? a2 : b2;
    return v0.weight === v1.weight ? v0.index - v1.index : v0.weight - v1.weight;
  });
}
function wrapBoxes(boxes) {
  const layoutBoxes = [];
  let i2, ilen, box, pos, stack, stackWeight;
  for (i2 = 0, ilen = (boxes || []).length; i2 < ilen; ++i2) {
    box = boxes[i2];
    ({ position: pos, options: { stack, stackWeight = 1 } } = box);
    layoutBoxes.push({
      index: i2,
      box,
      pos,
      horizontal: box.isHorizontal(),
      weight: box.weight,
      stack: stack && pos + stack,
      stackWeight
    });
  }
  return layoutBoxes;
}
function buildStacks(layouts2) {
  const stacks = {};
  for (const wrap of layouts2) {
    const { stack, pos, stackWeight } = wrap;
    if (!stack || !STATIC_POSITIONS.includes(pos)) {
      continue;
    }
    const _stack = stacks[stack] || (stacks[stack] = {
      count: 0,
      placed: 0,
      weight: 0,
      size: 0
    });
    _stack.count++;
    _stack.weight += stackWeight;
  }
  return stacks;
}
function setLayoutDims(layouts2, params) {
  const stacks = buildStacks(layouts2);
  const { vBoxMaxWidth, hBoxMaxHeight } = params;
  let i2, ilen, layout;
  for (i2 = 0, ilen = layouts2.length; i2 < ilen; ++i2) {
    layout = layouts2[i2];
    const { fullSize } = layout.box;
    const stack = stacks[layout.stack];
    const factor = stack && layout.stackWeight / stack.weight;
    if (layout.horizontal) {
      layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
      layout.height = hBoxMaxHeight;
    } else {
      layout.width = vBoxMaxWidth;
      layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
    }
  }
  return stacks;
}
function buildLayoutBoxes(boxes) {
  const layoutBoxes = wrapBoxes(boxes);
  const fullSize = sortByWeight(layoutBoxes.filter((wrap) => wrap.box.fullSize), true);
  const left = sortByWeight(filterByPosition(layoutBoxes, "left"), true);
  const right = sortByWeight(filterByPosition(layoutBoxes, "right"));
  const top = sortByWeight(filterByPosition(layoutBoxes, "top"), true);
  const bottom = sortByWeight(filterByPosition(layoutBoxes, "bottom"));
  const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, "x");
  const centerVertical = filterDynamicPositionByAxis(layoutBoxes, "y");
  return {
    fullSize,
    leftAndTop: left.concat(top),
    rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),
    chartArea: filterByPosition(layoutBoxes, "chartArea"),
    vertical: left.concat(right).concat(centerVertical),
    horizontal: top.concat(bottom).concat(centerHorizontal)
  };
}
function getCombinedMax(maxPadding, chartArea, a2, b2) {
  return Math.max(maxPadding[a2], chartArea[a2]) + Math.max(maxPadding[b2], chartArea[b2]);
}
function updateMaxPadding(maxPadding, boxPadding) {
  maxPadding.top = Math.max(maxPadding.top, boxPadding.top);
  maxPadding.left = Math.max(maxPadding.left, boxPadding.left);
  maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);
  maxPadding.right = Math.max(maxPadding.right, boxPadding.right);
}
function updateDims(chartArea, params, layout, stacks) {
  const { pos, box } = layout;
  const maxPadding = chartArea.maxPadding;
  if (!isObject(pos)) {
    if (layout.size) {
      chartArea[pos] -= layout.size;
    }
    const stack = stacks[layout.stack] || {
      size: 0,
      count: 1
    };
    stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);
    layout.size = stack.size / stack.count;
    chartArea[pos] += layout.size;
  }
  if (box.getPadding) {
    updateMaxPadding(maxPadding, box.getPadding());
  }
  const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, "left", "right"));
  const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, "top", "bottom"));
  const widthChanged = newWidth !== chartArea.w;
  const heightChanged = newHeight !== chartArea.h;
  chartArea.w = newWidth;
  chartArea.h = newHeight;
  return layout.horizontal ? {
    same: widthChanged,
    other: heightChanged
  } : {
    same: heightChanged,
    other: widthChanged
  };
}
function handleMaxPadding(chartArea) {
  const maxPadding = chartArea.maxPadding;
  function updatePos(pos) {
    const change = Math.max(maxPadding[pos] - chartArea[pos], 0);
    chartArea[pos] += change;
    return change;
  }
  chartArea.y += updatePos("top");
  chartArea.x += updatePos("left");
  updatePos("right");
  updatePos("bottom");
}
function getMargins(horizontal, chartArea) {
  const maxPadding = chartArea.maxPadding;
  function marginForPositions(positions2) {
    const margin = {
      left: 0,
      top: 0,
      right: 0,
      bottom: 0
    };
    positions2.forEach((pos) => {
      margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);
    });
    return margin;
  }
  return horizontal ? marginForPositions([
    "left",
    "right"
  ]) : marginForPositions([
    "top",
    "bottom"
  ]);
}
function fitBoxes(boxes, chartArea, params, stacks) {
  const refitBoxes = [];
  let i2, ilen, layout, box, refit, changed;
  for (i2 = 0, ilen = boxes.length, refit = 0; i2 < ilen; ++i2) {
    layout = boxes[i2];
    box = layout.box;
    box.update(layout.width || chartArea.w, layout.height || chartArea.h, getMargins(layout.horizontal, chartArea));
    const { same, other } = updateDims(chartArea, params, layout, stacks);
    refit |= same && refitBoxes.length;
    changed = changed || other;
    if (!box.fullSize) {
      refitBoxes.push(layout);
    }
  }
  return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;
}
function setBoxDims(box, left, top, width, height) {
  box.top = top;
  box.left = left;
  box.right = left + width;
  box.bottom = top + height;
  box.width = width;
  box.height = height;
}
function placeBoxes(boxes, chartArea, params, stacks) {
  const userPadding = params.padding;
  let { x: x2, y: y2 } = chartArea;
  for (const layout of boxes) {
    const box = layout.box;
    const stack = stacks[layout.stack] || {
      count: 1,
      placed: 0,
      weight: 1
    };
    const weight = layout.stackWeight / stack.weight || 1;
    if (layout.horizontal) {
      const width = chartArea.w * weight;
      const height = stack.size || box.height;
      if (defined(stack.start)) {
        y2 = stack.start;
      }
      if (box.fullSize) {
        setBoxDims(box, userPadding.left, y2, params.outerWidth - userPadding.right - userPadding.left, height);
      } else {
        setBoxDims(box, chartArea.left + stack.placed, y2, width, height);
      }
      stack.start = y2;
      stack.placed += width;
      y2 = box.bottom;
    } else {
      const height = chartArea.h * weight;
      const width = stack.size || box.width;
      if (defined(stack.start)) {
        x2 = stack.start;
      }
      if (box.fullSize) {
        setBoxDims(box, x2, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);
      } else {
        setBoxDims(box, x2, chartArea.top + stack.placed, width, height);
      }
      stack.start = x2;
      stack.placed += height;
      x2 = box.right;
    }
  }
  chartArea.x = x2;
  chartArea.y = y2;
}
var layouts = {
  addBox(chart, item) {
    if (!chart.boxes) {
      chart.boxes = [];
    }
    item.fullSize = item.fullSize || false;
    item.position = item.position || "top";
    item.weight = item.weight || 0;
    item._layers = item._layers || function() {
      return [
        {
          z: 0,
          draw(chartArea) {
            item.draw(chartArea);
          }
        }
      ];
    };
    chart.boxes.push(item);
  },
  removeBox(chart, layoutItem) {
    const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;
    if (index !== -1) {
      chart.boxes.splice(index, 1);
    }
  },
  configure(chart, item, options) {
    item.fullSize = options.fullSize;
    item.position = options.position;
    item.weight = options.weight;
  },
  update(chart, width, height, minPadding) {
    if (!chart) {
      return;
    }
    const padding = toPadding(chart.options.layout.padding);
    const availableWidth = Math.max(width - padding.width, 0);
    const availableHeight = Math.max(height - padding.height, 0);
    const boxes = buildLayoutBoxes(chart.boxes);
    const verticalBoxes = boxes.vertical;
    const horizontalBoxes = boxes.horizontal;
    each(chart.boxes, (box) => {
      if (typeof box.beforeLayout === "function") {
        box.beforeLayout();
      }
    });
    const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) => wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;
    const params = Object.freeze({
      outerWidth: width,
      outerHeight: height,
      padding,
      availableWidth,
      availableHeight,
      vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,
      hBoxMaxHeight: availableHeight / 2
    });
    const maxPadding = Object.assign({}, padding);
    updateMaxPadding(maxPadding, toPadding(minPadding));
    const chartArea = Object.assign({
      maxPadding,
      w: availableWidth,
      h: availableHeight,
      x: padding.left,
      y: padding.top
    }, padding);
    const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);
    fitBoxes(boxes.fullSize, chartArea, params, stacks);
    fitBoxes(verticalBoxes, chartArea, params, stacks);
    if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {
      fitBoxes(verticalBoxes, chartArea, params, stacks);
    }
    handleMaxPadding(chartArea);
    placeBoxes(boxes.leftAndTop, chartArea, params, stacks);
    chartArea.x += chartArea.w;
    chartArea.y += chartArea.h;
    placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);
    chart.chartArea = {
      left: chartArea.left,
      top: chartArea.top,
      right: chartArea.left + chartArea.w,
      bottom: chartArea.top + chartArea.h,
      height: chartArea.h,
      width: chartArea.w
    };
    each(boxes.chartArea, (layout) => {
      const box = layout.box;
      Object.assign(box, chart.chartArea);
      box.update(chartArea.w, chartArea.h, {
        left: 0,
        top: 0,
        right: 0,
        bottom: 0
      });
    });
  }
};
var BasePlatform = class {
  acquireContext(canvas, aspectRatio) {
  }
  releaseContext(context) {
    return false;
  }
  addEventListener(chart, type, listener) {
  }
  removeEventListener(chart, type, listener) {
  }
  getDevicePixelRatio() {
    return 1;
  }
  getMaximumSize(element, width, height, aspectRatio) {
    width = Math.max(0, width || element.width);
    height = height || element.height;
    return {
      width,
      height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)
    };
  }
  isAttached(canvas) {
    return true;
  }
  updateConfig(config) {
  }
};
var BasicPlatform = class extends BasePlatform {
  acquireContext(item) {
    return item && item.getContext && item.getContext("2d") || null;
  }
  updateConfig(config) {
    config.options.animation = false;
  }
};
var EXPANDO_KEY = "$chartjs";
var EVENT_TYPES = {
  touchstart: "mousedown",
  touchmove: "mousemove",
  touchend: "mouseup",
  pointerenter: "mouseenter",
  pointerdown: "mousedown",
  pointermove: "mousemove",
  pointerup: "mouseup",
  pointerleave: "mouseout",
  pointerout: "mouseout"
};
var isNullOrEmpty = (value) => value === null || value === "";
function initCanvas(canvas, aspectRatio) {
  const style = canvas.style;
  const renderHeight = canvas.getAttribute("height");
  const renderWidth = canvas.getAttribute("width");
  canvas[EXPANDO_KEY] = {
    initial: {
      height: renderHeight,
      width: renderWidth,
      style: {
        display: style.display,
        height: style.height,
        width: style.width
      }
    }
  };
  style.display = style.display || "block";
  style.boxSizing = style.boxSizing || "border-box";
  if (isNullOrEmpty(renderWidth)) {
    const displayWidth = readUsedSize(canvas, "width");
    if (displayWidth !== void 0) {
      canvas.width = displayWidth;
    }
  }
  if (isNullOrEmpty(renderHeight)) {
    if (canvas.style.height === "") {
      canvas.height = canvas.width / (aspectRatio || 2);
    } else {
      const displayHeight = readUsedSize(canvas, "height");
      if (displayHeight !== void 0) {
        canvas.height = displayHeight;
      }
    }
  }
  return canvas;
}
var eventListenerOptions = supportsEventListenerOptions ? {
  passive: true
} : false;
function addListener(node, type, listener) {
  if (node) {
    node.addEventListener(type, listener, eventListenerOptions);
  }
}
function removeListener(chart, type, listener) {
  if (chart && chart.canvas) {
    chart.canvas.removeEventListener(type, listener, eventListenerOptions);
  }
}
function fromNativeEvent(event, chart) {
  const type = EVENT_TYPES[event.type] || event.type;
  const { x: x2, y: y2 } = getRelativePosition(event, chart);
  return {
    type,
    chart,
    native: event,
    x: x2 !== void 0 ? x2 : null,
    y: y2 !== void 0 ? y2 : null
  };
}
function nodeListContains(nodeList, canvas) {
  for (const node of nodeList) {
    if (node === canvas || node.contains(canvas)) {
      return true;
    }
  }
}
function createAttachObserver(chart, type, listener) {
  const canvas = chart.canvas;
  const observer = new MutationObserver((entries) => {
    let trigger = false;
    for (const entry of entries) {
      trigger = trigger || nodeListContains(entry.addedNodes, canvas);
      trigger = trigger && !nodeListContains(entry.removedNodes, canvas);
    }
    if (trigger) {
      listener();
    }
  });
  observer.observe(document, {
    childList: true,
    subtree: true
  });
  return observer;
}
function createDetachObserver(chart, type, listener) {
  const canvas = chart.canvas;
  const observer = new MutationObserver((entries) => {
    let trigger = false;
    for (const entry of entries) {
      trigger = trigger || nodeListContains(entry.removedNodes, canvas);
      trigger = trigger && !nodeListContains(entry.addedNodes, canvas);
    }
    if (trigger) {
      listener();
    }
  });
  observer.observe(document, {
    childList: true,
    subtree: true
  });
  return observer;
}
var drpListeningCharts = /* @__PURE__ */ new Map();
var oldDevicePixelRatio = 0;
function onWindowResize() {
  const dpr = window.devicePixelRatio;
  if (dpr === oldDevicePixelRatio) {
    return;
  }
  oldDevicePixelRatio = dpr;
  drpListeningCharts.forEach((resize, chart) => {
    if (chart.currentDevicePixelRatio !== dpr) {
      resize();
    }
  });
}
function listenDevicePixelRatioChanges(chart, resize) {
  if (!drpListeningCharts.size) {
    window.addEventListener("resize", onWindowResize);
  }
  drpListeningCharts.set(chart, resize);
}
function unlistenDevicePixelRatioChanges(chart) {
  drpListeningCharts.delete(chart);
  if (!drpListeningCharts.size) {
    window.removeEventListener("resize", onWindowResize);
  }
}
function createResizeObserver(chart, type, listener) {
  const canvas = chart.canvas;
  const container = canvas && _getParentNode(canvas);
  if (!container) {
    return;
  }
  const resize = throttled((width, height) => {
    const w2 = container.clientWidth;
    listener(width, height);
    if (w2 < container.clientWidth) {
      listener();
    }
  }, window);
  const observer = new ResizeObserver((entries) => {
    const entry = entries[0];
    const width = entry.contentRect.width;
    const height = entry.contentRect.height;
    if (width === 0 && height === 0) {
      return;
    }
    resize(width, height);
  });
  observer.observe(container);
  listenDevicePixelRatioChanges(chart, resize);
  return observer;
}
function releaseObserver(chart, type, observer) {
  if (observer) {
    observer.disconnect();
  }
  if (type === "resize") {
    unlistenDevicePixelRatioChanges(chart);
  }
}
function createProxyAndListen(chart, type, listener) {
  const canvas = chart.canvas;
  const proxy = throttled((event) => {
    if (chart.ctx !== null) {
      listener(fromNativeEvent(event, chart));
    }
  }, chart);
  addListener(canvas, type, proxy);
  return proxy;
}
var DomPlatform = class extends BasePlatform {
  acquireContext(canvas, aspectRatio) {
    const context = canvas && canvas.getContext && canvas.getContext("2d");
    if (context && context.canvas === canvas) {
      initCanvas(canvas, aspectRatio);
      return context;
    }
    return null;
  }
  releaseContext(context) {
    const canvas = context.canvas;
    if (!canvas[EXPANDO_KEY]) {
      return false;
    }
    const initial = canvas[EXPANDO_KEY].initial;
    [
      "height",
      "width"
    ].forEach((prop) => {
      const value = initial[prop];
      if (isNullOrUndef(value)) {
        canvas.removeAttribute(prop);
      } else {
        canvas.setAttribute(prop, value);
      }
    });
    const style = initial.style || {};
    Object.keys(style).forEach((key) => {
      canvas.style[key] = style[key];
    });
    canvas.width = canvas.width;
    delete canvas[EXPANDO_KEY];
    return true;
  }
  addEventListener(chart, type, listener) {
    this.removeEventListener(chart, type);
    const proxies = chart.$proxies || (chart.$proxies = {});
    const handlers = {
      attach: createAttachObserver,
      detach: createDetachObserver,
      resize: createResizeObserver
    };
    const handler = handlers[type] || createProxyAndListen;
    proxies[type] = handler(chart, type, listener);
  }
  removeEventListener(chart, type) {
    const proxies = chart.$proxies || (chart.$proxies = {});
    const proxy = proxies[type];
    if (!proxy) {
      return;
    }
    const handlers = {
      attach: releaseObserver,
      detach: releaseObserver,
      resize: releaseObserver
    };
    const handler = handlers[type] || removeListener;
    handler(chart, type, proxy);
    proxies[type] = void 0;
  }
  getDevicePixelRatio() {
    return window.devicePixelRatio;
  }
  getMaximumSize(canvas, width, height, aspectRatio) {
    return getMaximumSize(canvas, width, height, aspectRatio);
  }
  isAttached(canvas) {
    const container = canvas && _getParentNode(canvas);
    return !!(container && container.isConnected);
  }
};
function _detectPlatform(canvas) {
  if (!_isDomSupported() || typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas) {
    return BasicPlatform;
  }
  return DomPlatform;
}
var Element = class {
  constructor() {
    __publicField(this, "x");
    __publicField(this, "y");
    __publicField(this, "active", false);
    __publicField(this, "options");
    __publicField(this, "$animations");
  }
  tooltipPosition(useFinalPosition) {
    const { x: x2, y: y2 } = this.getProps([
      "x",
      "y"
    ], useFinalPosition);
    return {
      x: x2,
      y: y2
    };
  }
  hasValue() {
    return isNumber(this.x) && isNumber(this.y);
  }
  getProps(props, final) {
    const anims = this.$animations;
    if (!final || !anims) {
      return this;
    }
    const ret = {};
    props.forEach((prop) => {
      ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];
    });
    return ret;
  }
};
__publicField(Element, "defaults", {});
__publicField(Element, "defaultRoutes");
function autoSkip(scale, ticks) {
  const tickOpts = scale.options.ticks;
  const determinedMaxTicks = determineMaxTicks(scale);
  const ticksLimit = Math.min(tickOpts.maxTicksLimit || determinedMaxTicks, determinedMaxTicks);
  const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];
  const numMajorIndices = majorIndices.length;
  const first = majorIndices[0];
  const last = majorIndices[numMajorIndices - 1];
  const newTicks = [];
  if (numMajorIndices > ticksLimit) {
    skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);
    return newTicks;
  }
  const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);
  if (numMajorIndices > 0) {
    let i2, ilen;
    const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;
    skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
    for (i2 = 0, ilen = numMajorIndices - 1; i2 < ilen; i2++) {
      skip(ticks, newTicks, spacing, majorIndices[i2], majorIndices[i2 + 1]);
    }
    skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
    return newTicks;
  }
  skip(ticks, newTicks, spacing);
  return newTicks;
}
function determineMaxTicks(scale) {
  const offset = scale.options.offset;
  const tickLength = scale._tickSize();
  const maxScale = scale._length / tickLength + (offset ? 0 : 1);
  const maxChart = scale._maxLength / tickLength;
  return Math.floor(Math.min(maxScale, maxChart));
}
function calculateSpacing(majorIndices, ticks, ticksLimit) {
  const evenMajorSpacing = getEvenSpacing(majorIndices);
  const spacing = ticks.length / ticksLimit;
  if (!evenMajorSpacing) {
    return Math.max(spacing, 1);
  }
  const factors = _factorize(evenMajorSpacing);
  for (let i2 = 0, ilen = factors.length - 1; i2 < ilen; i2++) {
    const factor = factors[i2];
    if (factor > spacing) {
      return factor;
    }
  }
  return Math.max(spacing, 1);
}
function getMajorIndices(ticks) {
  const result = [];
  let i2, ilen;
  for (i2 = 0, ilen = ticks.length; i2 < ilen; i2++) {
    if (ticks[i2].major) {
      result.push(i2);
    }
  }
  return result;
}
function skipMajors(ticks, newTicks, majorIndices, spacing) {
  let count = 0;
  let next = majorIndices[0];
  let i2;
  spacing = Math.ceil(spacing);
  for (i2 = 0; i2 < ticks.length; i2++) {
    if (i2 === next) {
      newTicks.push(ticks[i2]);
      count++;
      next = majorIndices[count * spacing];
    }
  }
}
function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
  const start = valueOrDefault(majorStart, 0);
  const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);
  let count = 0;
  let length, i2, next;
  spacing = Math.ceil(spacing);
  if (majorEnd) {
    length = majorEnd - majorStart;
    spacing = length / Math.floor(length / spacing);
  }
  next = start;
  while (next < 0) {
    count++;
    next = Math.round(start + count * spacing);
  }
  for (i2 = Math.max(start, 0); i2 < end; i2++) {
    if (i2 === next) {
      newTicks.push(ticks[i2]);
      count++;
      next = Math.round(start + count * spacing);
    }
  }
}
function getEvenSpacing(arr) {
  const len = arr.length;
  let i2, diff;
  if (len < 2) {
    return false;
  }
  for (diff = arr[0], i2 = 1; i2 < len; ++i2) {
    if (arr[i2] - arr[i2 - 1] !== diff) {
      return false;
    }
  }
  return diff;
}
var reverseAlign = (align) => align === "left" ? "right" : align === "right" ? "left" : align;
var offsetFromEdge = (scale, edge, offset) => edge === "top" || edge === "left" ? scale[edge] + offset : scale[edge] - offset;
var getTicksLimit = (ticksLength, maxTicksLimit) => Math.min(maxTicksLimit || ticksLength, ticksLength);
function sample(arr, numItems) {
  const result = [];
  const increment = arr.length / numItems;
  const len = arr.length;
  let i2 = 0;
  for (; i2 < len; i2 += increment) {
    result.push(arr[Math.floor(i2)]);
  }
  return result;
}
function getPixelForGridLine(scale, index, offsetGridLines) {
  const length = scale.ticks.length;
  const validIndex2 = Math.min(index, length - 1);
  const start = scale._startPixel;
  const end = scale._endPixel;
  const epsilon = 1e-6;
  let lineValue = scale.getPixelForTick(validIndex2);
  let offset;
  if (offsetGridLines) {
    if (length === 1) {
      offset = Math.max(lineValue - start, end - lineValue);
    } else if (index === 0) {
      offset = (scale.getPixelForTick(1) - lineValue) / 2;
    } else {
      offset = (lineValue - scale.getPixelForTick(validIndex2 - 1)) / 2;
    }
    lineValue += validIndex2 < index ? offset : -offset;
    if (lineValue < start - epsilon || lineValue > end + epsilon) {
      return;
    }
  }
  return lineValue;
}
function garbageCollect(caches, length) {
  each(caches, (cache) => {
    const gc = cache.gc;
    const gcLen = gc.length / 2;
    let i2;
    if (gcLen > length) {
      for (i2 = 0; i2 < gcLen; ++i2) {
        delete cache.data[gc[i2]];
      }
      gc.splice(0, gcLen);
    }
  });
}
function getTickMarkLength(options) {
  return options.drawTicks ? options.tickLength : 0;
}
function getTitleHeight(options, fallback) {
  if (!options.display) {
    return 0;
  }
  const font = toFont(options.font, fallback);
  const padding = toPadding(options.padding);
  const lines = isArray(options.text) ? options.text.length : 1;
  return lines * font.lineHeight + padding.height;
}
function createScaleContext(parent, scale) {
  return createContext(parent, {
    scale,
    type: "scale"
  });
}
function createTickContext(parent, index, tick) {
  return createContext(parent, {
    tick,
    index,
    type: "tick"
  });
}
function titleAlign(align, position, reverse) {
  let ret = _toLeftRightCenter(align);
  if (reverse && position !== "right" || !reverse && position === "right") {
    ret = reverseAlign(ret);
  }
  return ret;
}
function titleArgs(scale, offset, position, align) {
  const { top, left, bottom, right, chart } = scale;
  const { chartArea, scales } = chart;
  let rotation = 0;
  let maxWidth, titleX, titleY;
  const height = bottom - top;
  const width = right - left;
  if (scale.isHorizontal()) {
    titleX = _alignStartEnd(align, left, right);
    if (isObject(position)) {
      const positionAxisID = Object.keys(position)[0];
      const value = position[positionAxisID];
      titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;
    } else if (position === "center") {
      titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;
    } else {
      titleY = offsetFromEdge(scale, position, offset);
    }
    maxWidth = right - left;
  } else {
    if (isObject(position)) {
      const positionAxisID = Object.keys(position)[0];
      const value = position[positionAxisID];
      titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;
    } else if (position === "center") {
      titleX = (chartArea.left + chartArea.right) / 2 - width + offset;
    } else {
      titleX = offsetFromEdge(scale, position, offset);
    }
    titleY = _alignStartEnd(align, bottom, top);
    rotation = position === "left" ? -HALF_PI : HALF_PI;
  }
  return {
    titleX,
    titleY,
    maxWidth,
    rotation
  };
}
var Scale = class _Scale extends Element {
  constructor(cfg) {
    super();
    this.id = cfg.id;
    this.type = cfg.type;
    this.options = void 0;
    this.ctx = cfg.ctx;
    this.chart = cfg.chart;
    this.top = void 0;
    this.bottom = void 0;
    this.left = void 0;
    this.right = void 0;
    this.width = void 0;
    this.height = void 0;
    this._margins = {
      left: 0,
      right: 0,
      top: 0,
      bottom: 0
    };
    this.maxWidth = void 0;
    this.maxHeight = void 0;
    this.paddingTop = void 0;
    this.paddingBottom = void 0;
    this.paddingLeft = void 0;
    this.paddingRight = void 0;
    this.axis = void 0;
    this.labelRotation = void 0;
    this.min = void 0;
    this.max = void 0;
    this._range = void 0;
    this.ticks = [];
    this._gridLineItems = null;
    this._labelItems = null;
    this._labelSizes = null;
    this._length = 0;
    this._maxLength = 0;
    this._longestTextCache = {};
    this._startPixel = void 0;
    this._endPixel = void 0;
    this._reversePixels = false;
    this._userMax = void 0;
    this._userMin = void 0;
    this._suggestedMax = void 0;
    this._suggestedMin = void 0;
    this._ticksLength = 0;
    this._borderValue = 0;
    this._cache = {};
    this._dataLimitsCached = false;
    this.$context = void 0;
  }
  init(options) {
    this.options = options.setContext(this.getContext());
    this.axis = options.axis;
    this._userMin = this.parse(options.min);
    this._userMax = this.parse(options.max);
    this._suggestedMin = this.parse(options.suggestedMin);
    this._suggestedMax = this.parse(options.suggestedMax);
  }
  parse(raw, index) {
    return raw;
  }
  getUserBounds() {
    let { _userMin, _userMax, _suggestedMin, _suggestedMax } = this;
    _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);
    _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);
    _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);
    _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);
    return {
      min: finiteOrDefault(_userMin, _suggestedMin),
      max: finiteOrDefault(_userMax, _suggestedMax),
      minDefined: isNumberFinite(_userMin),
      maxDefined: isNumberFinite(_userMax)
    };
  }
  getMinMax(canStack) {
    let { min, max, minDefined, maxDefined } = this.getUserBounds();
    let range2;
    if (minDefined && maxDefined) {
      return {
        min,
        max
      };
    }
    const metas = this.getMatchingVisibleMetas();
    for (let i2 = 0, ilen = metas.length; i2 < ilen; ++i2) {
      range2 = metas[i2].controller.getMinMax(this, canStack);
      if (!minDefined) {
        min = Math.min(min, range2.min);
      }
      if (!maxDefined) {
        max = Math.max(max, range2.max);
      }
    }
    min = maxDefined && min > max ? max : min;
    max = minDefined && min > max ? min : max;
    return {
      min: finiteOrDefault(min, finiteOrDefault(max, min)),
      max: finiteOrDefault(max, finiteOrDefault(min, max))
    };
  }
  getPadding() {
    return {
      left: this.paddingLeft || 0,
      top: this.paddingTop || 0,
      right: this.paddingRight || 0,
      bottom: this.paddingBottom || 0
    };
  }
  getTicks() {
    return this.ticks;
  }
  getLabels() {
    const data = this.chart.data;
    return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];
  }
  getLabelItems(chartArea = this.chart.chartArea) {
    const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));
    return items;
  }
  beforeLayout() {
    this._cache = {};
    this._dataLimitsCached = false;
  }
  beforeUpdate() {
    callback(this.options.beforeUpdate, [
      this
    ]);
  }
  update(maxWidth, maxHeight, margins) {
    const { beginAtZero, grace, ticks: tickOpts } = this.options;
    const sampleSize = tickOpts.sampleSize;
    this.beforeUpdate();
    this.maxWidth = maxWidth;
    this.maxHeight = maxHeight;
    this._margins = margins = Object.assign({
      left: 0,
      right: 0,
      top: 0,
      bottom: 0
    }, margins);
    this.ticks = null;
    this._labelSizes = null;
    this._gridLineItems = null;
    this._labelItems = null;
    this.beforeSetDimensions();
    this.setDimensions();
    this.afterSetDimensions();
    this._maxLength = this.isHorizontal() ? this.width + margins.left + margins.right : this.height + margins.top + margins.bottom;
    if (!this._dataLimitsCached) {
      this.beforeDataLimits();
      this.determineDataLimits();
      this.afterDataLimits();
      this._range = _addGrace(this, grace, beginAtZero);
      this._dataLimitsCached = true;
    }
    this.beforeBuildTicks();
    this.ticks = this.buildTicks() || [];
    this.afterBuildTicks();
    const samplingEnabled = sampleSize < this.ticks.length;
    this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);
    this.configure();
    this.beforeCalculateLabelRotation();
    this.calculateLabelRotation();
    this.afterCalculateLabelRotation();
    if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === "auto")) {
      this.ticks = autoSkip(this, this.ticks);
      this._labelSizes = null;
      this.afterAutoSkip();
    }
    if (samplingEnabled) {
      this._convertTicksToLabels(this.ticks);
    }
    this.beforeFit();
    this.fit();
    this.afterFit();
    this.afterUpdate();
  }
  configure() {
    let reversePixels = this.options.reverse;
    let startPixel, endPixel;
    if (this.isHorizontal()) {
      startPixel = this.left;
      endPixel = this.right;
    } else {
      startPixel = this.top;
      endPixel = this.bottom;
      reversePixels = !reversePixels;
    }
    this._startPixel = startPixel;
    this._endPixel = endPixel;
    this._reversePixels = reversePixels;
    this._length = endPixel - startPixel;
    this._alignToPixels = this.options.alignToPixels;
  }
  afterUpdate() {
    callback(this.options.afterUpdate, [
      this
    ]);
  }
  beforeSetDimensions() {
    callback(this.options.beforeSetDimensions, [
      this
    ]);
  }
  setDimensions() {
    if (this.isHorizontal()) {
      this.width = this.maxWidth;
      this.left = 0;
      this.right = this.width;
    } else {
      this.height = this.maxHeight;
      this.top = 0;
      this.bottom = this.height;
    }
    this.paddingLeft = 0;
    this.paddingTop = 0;
    this.paddingRight = 0;
    this.paddingBottom = 0;
  }
  afterSetDimensions() {
    callback(this.options.afterSetDimensions, [
      this
    ]);
  }
  _callHooks(name) {
    this.chart.notifyPlugins(name, this.getContext());
    callback(this.options[name], [
      this
    ]);
  }
  beforeDataLimits() {
    this._callHooks("beforeDataLimits");
  }
  determineDataLimits() {
  }
  afterDataLimits() {
    this._callHooks("afterDataLimits");
  }
  beforeBuildTicks() {
    this._callHooks("beforeBuildTicks");
  }
  buildTicks() {
    return [];
  }
  afterBuildTicks() {
    this._callHooks("afterBuildTicks");
  }
  beforeTickToLabelConversion() {
    callback(this.options.beforeTickToLabelConversion, [
      this
    ]);
  }
  generateTickLabels(ticks) {
    const tickOpts = this.options.ticks;
    let i2, ilen, tick;
    for (i2 = 0, ilen = ticks.length; i2 < ilen; i2++) {
      tick = ticks[i2];
      tick.label = callback(tickOpts.callback, [
        tick.value,
        i2,
        ticks
      ], this);
    }
  }
  afterTickToLabelConversion() {
    callback(this.options.afterTickToLabelConversion, [
      this
    ]);
  }
  beforeCalculateLabelRotation() {
    callback(this.options.beforeCalculateLabelRotation, [
      this
    ]);
  }
  calculateLabelRotation() {
    const options = this.options;
    const tickOpts = options.ticks;
    const numTicks = getTicksLimit(this.ticks.length, options.ticks.maxTicksLimit);
    const minRotation = tickOpts.minRotation || 0;
    const maxRotation = tickOpts.maxRotation;
    let labelRotation = minRotation;
    let tickWidth, maxHeight, maxLabelDiagonal;
    if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {
      this.labelRotation = minRotation;
      return;
    }
    const labelSizes = this._getLabelSizes();
    const maxLabelWidth = labelSizes.widest.width;
    const maxLabelHeight = labelSizes.highest.height;
    const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);
    tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);
    if (maxLabelWidth + 6 > tickWidth) {
      tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));
      maxHeight = this.maxHeight - getTickMarkLength(options.grid) - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);
      maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);
      labelRotation = toDegrees(Math.min(Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)), Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))));
      labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));
    }
    this.labelRotation = labelRotation;
  }
  afterCalculateLabelRotation() {
    callback(this.options.afterCalculateLabelRotation, [
      this
    ]);
  }
  afterAutoSkip() {
  }
  beforeFit() {
    callback(this.options.beforeFit, [
      this
    ]);
  }
  fit() {
    const minSize = {
      width: 0,
      height: 0
    };
    const { chart, options: { ticks: tickOpts, title: titleOpts, grid: gridOpts } } = this;
    const display = this._isVisible();
    const isHorizontal = this.isHorizontal();
    if (display) {
      const titleHeight = getTitleHeight(titleOpts, chart.options.font);
      if (isHorizontal) {
        minSize.width = this.maxWidth;
        minSize.height = getTickMarkLength(gridOpts) + titleHeight;
      } else {
        minSize.height = this.maxHeight;
        minSize.width = getTickMarkLength(gridOpts) + titleHeight;
      }
      if (tickOpts.display && this.ticks.length) {
        const { first, last, widest, highest } = this._getLabelSizes();
        const tickPadding = tickOpts.padding * 2;
        const angleRadians = toRadians(this.labelRotation);
        const cos = Math.cos(angleRadians);
        const sin = Math.sin(angleRadians);
        if (isHorizontal) {
          const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;
          minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);
        } else {
          const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;
          minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);
        }
        this._calculatePadding(first, last, sin, cos);
      }
    }
    this._handleMargins();
    if (isHorizontal) {
      this.width = this._length = chart.width - this._margins.left - this._margins.right;
      this.height = minSize.height;
    } else {
      this.width = minSize.width;
      this.height = this._length = chart.height - this._margins.top - this._margins.bottom;
    }
  }
  _calculatePadding(first, last, sin, cos) {
    const { ticks: { align, padding }, position } = this.options;
    const isRotated = this.labelRotation !== 0;
    const labelsBelowTicks = position !== "top" && this.axis === "x";
    if (this.isHorizontal()) {
      const offsetLeft = this.getPixelForTick(0) - this.left;
      const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);
      let paddingLeft = 0;
      let paddingRight = 0;
      if (isRotated) {
        if (labelsBelowTicks) {
          paddingLeft = cos * first.width;
          paddingRight = sin * last.height;
        } else {
          paddingLeft = sin * first.height;
          paddingRight = cos * last.width;
        }
      } else if (align === "start") {
        paddingRight = last.width;
      } else if (align === "end") {
        paddingLeft = first.width;
      } else if (align !== "inner") {
        paddingLeft = first.width / 2;
        paddingRight = last.width / 2;
      }
      this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);
      this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);
    } else {
      let paddingTop = last.height / 2;
      let paddingBottom = first.height / 2;
      if (align === "start") {
        paddingTop = 0;
        paddingBottom = first.height;
      } else if (align === "end") {
        paddingTop = last.height;
        paddingBottom = 0;
      }
      this.paddingTop = paddingTop + padding;
      this.paddingBottom = paddingBottom + padding;
    }
  }
  _handleMargins() {
    if (this._margins) {
      this._margins.left = Math.max(this.paddingLeft, this._margins.left);
      this._margins.top = Math.max(this.paddingTop, this._margins.top);
      this._margins.right = Math.max(this.paddingRight, this._margins.right);
      this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);
    }
  }
  afterFit() {
    callback(this.options.afterFit, [
      this
    ]);
  }
  isHorizontal() {
    const { axis, position } = this.options;
    return position === "top" || position === "bottom" || axis === "x";
  }
  isFullSize() {
    return this.options.fullSize;
  }
  _convertTicksToLabels(ticks) {
    this.beforeTickToLabelConversion();
    this.generateTickLabels(ticks);
    let i2, ilen;
    for (i2 = 0, ilen = ticks.length; i2 < ilen; i2++) {
      if (isNullOrUndef(ticks[i2].label)) {
        ticks.splice(i2, 1);
        ilen--;
        i2--;
      }
    }
    this.afterTickToLabelConversion();
  }
  _getLabelSizes() {
    let labelSizes = this._labelSizes;
    if (!labelSizes) {
      const sampleSize = this.options.ticks.sampleSize;
      let ticks = this.ticks;
      if (sampleSize < ticks.length) {
        ticks = sample(ticks, sampleSize);
      }
      this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length, this.options.ticks.maxTicksLimit);
    }
    return labelSizes;
  }
  _computeLabelSizes(ticks, length, maxTicksLimit) {
    const { ctx, _longestTextCache: caches } = this;
    const widths = [];
    const heights = [];
    const increment = Math.floor(length / getTicksLimit(length, maxTicksLimit));
    let widestLabelSize = 0;
    let highestLabelSize = 0;
    let i2, j2, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;
    for (i2 = 0; i2 < length; i2 += increment) {
      label = ticks[i2].label;
      tickFont = this._resolveTickFontOptions(i2);
      ctx.font = fontString = tickFont.string;
      cache = caches[fontString] = caches[fontString] || {
        data: {},
        gc: []
      };
      lineHeight = tickFont.lineHeight;
      width = height = 0;
      if (!isNullOrUndef(label) && !isArray(label)) {
        width = _measureText(ctx, cache.data, cache.gc, width, label);
        height = lineHeight;
      } else if (isArray(label)) {
        for (j2 = 0, jlen = label.length; j2 < jlen; ++j2) {
          nestedLabel = label[j2];
          if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {
            width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);
            height += lineHeight;
          }
        }
      }
      widths.push(width);
      heights.push(height);
      widestLabelSize = Math.max(width, widestLabelSize);
      highestLabelSize = Math.max(height, highestLabelSize);
    }
    garbageCollect(caches, length);
    const widest = widths.indexOf(widestLabelSize);
    const highest = heights.indexOf(highestLabelSize);
    const valueAt = (idx) => ({
      width: widths[idx] || 0,
      height: heights[idx] || 0
    });
    return {
      first: valueAt(0),
      last: valueAt(length - 1),
      widest: valueAt(widest),
      highest: valueAt(highest),
      widths,
      heights
    };
  }
  getLabelForValue(value) {
    return value;
  }
  getPixelForValue(value, index) {
    return NaN;
  }
  getValueForPixel(pixel) {
  }
  getPixelForTick(index) {
    const ticks = this.ticks;
    if (index < 0 || index > ticks.length - 1) {
      return null;
    }
    return this.getPixelForValue(ticks[index].value);
  }
  getPixelForDecimal(decimal) {
    if (this._reversePixels) {
      decimal = 1 - decimal;
    }
    const pixel = this._startPixel + decimal * this._length;
    return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);
  }
  getDecimalForPixel(pixel) {
    const decimal = (pixel - this._startPixel) / this._length;
    return this._reversePixels ? 1 - decimal : decimal;
  }
  getBasePixel() {
    return this.getPixelForValue(this.getBaseValue());
  }
  getBaseValue() {
    const { min, max } = this;
    return min < 0 && max < 0 ? max : min > 0 && max > 0 ? min : 0;
  }
  getContext(index) {
    const ticks = this.ticks || [];
    if (index >= 0 && index < ticks.length) {
      const tick = ticks[index];
      return tick.$context || (tick.$context = createTickContext(this.getContext(), index, tick));
    }
    return this.$context || (this.$context = createScaleContext(this.chart.getContext(), this));
  }
  _tickSize() {
    const optionTicks = this.options.ticks;
    const rot = toRadians(this.labelRotation);
    const cos = Math.abs(Math.cos(rot));
    const sin = Math.abs(Math.sin(rot));
    const labelSizes = this._getLabelSizes();
    const padding = optionTicks.autoSkipPadding || 0;
    const w2 = labelSizes ? labelSizes.widest.width + padding : 0;
    const h3 = labelSizes ? labelSizes.highest.height + padding : 0;
    return this.isHorizontal() ? h3 * cos > w2 * sin ? w2 / cos : h3 / sin : h3 * sin < w2 * cos ? h3 / cos : w2 / sin;
  }
  _isVisible() {
    const display = this.options.display;
    if (display !== "auto") {
      return !!display;
    }
    return this.getMatchingVisibleMetas().length > 0;
  }
  _computeGridLineItems(chartArea) {
    const axis = this.axis;
    const chart = this.chart;
    const options = this.options;
    const { grid, position, border } = options;
    const offset = grid.offset;
    const isHorizontal = this.isHorizontal();
    const ticks = this.ticks;
    const ticksLength = ticks.length + (offset ? 1 : 0);
    const tl = getTickMarkLength(grid);
    const items = [];
    const borderOpts = border.setContext(this.getContext());
    const axisWidth = borderOpts.display ? borderOpts.width : 0;
    const axisHalfWidth = axisWidth / 2;
    const alignBorderValue = function(pixel) {
      return _alignPixel(chart, pixel, axisWidth);
    };
    let borderValue, i2, lineValue, alignedLineValue;
    let tx1, ty1, tx2, ty2, x1, y1, x2, y2;
    if (position === "top") {
      borderValue = alignBorderValue(this.bottom);
      ty1 = this.bottom - tl;
      ty2 = borderValue - axisHalfWidth;
      y1 = alignBorderValue(chartArea.top) + axisHalfWidth;
      y2 = chartArea.bottom;
    } else if (position === "bottom") {
      borderValue = alignBorderValue(this.top);
      y1 = chartArea.top;
      y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;
      ty1 = borderValue + axisHalfWidth;
      ty2 = this.top + tl;
    } else if (position === "left") {
      borderValue = alignBorderValue(this.right);
      tx1 = this.right - tl;
      tx2 = borderValue - axisHalfWidth;
      x1 = alignBorderValue(chartArea.left) + axisHalfWidth;
      x2 = chartArea.right;
    } else if (position === "right") {
      borderValue = alignBorderValue(this.left);
      x1 = chartArea.left;
      x2 = alignBorderValue(chartArea.right) - axisHalfWidth;
      tx1 = borderValue + axisHalfWidth;
      tx2 = this.left + tl;
    } else if (axis === "x") {
      if (position === "center") {
        borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);
      } else if (isObject(position)) {
        const positionAxisID = Object.keys(position)[0];
        const value = position[positionAxisID];
        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
      }
      y1 = chartArea.top;
      y2 = chartArea.bottom;
      ty1 = borderValue + axisHalfWidth;
      ty2 = ty1 + tl;
    } else if (axis === "y") {
      if (position === "center") {
        borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);
      } else if (isObject(position)) {
        const positionAxisID = Object.keys(position)[0];
        const value = position[positionAxisID];
        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
      }
      tx1 = borderValue - axisHalfWidth;
      tx2 = tx1 - tl;
      x1 = chartArea.left;
      x2 = chartArea.right;
    }
    const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);
    const step = Math.max(1, Math.ceil(ticksLength / limit));
    for (i2 = 0; i2 < ticksLength; i2 += step) {
      const context = this.getContext(i2);
      const optsAtIndex = grid.setContext(context);
      const optsAtIndexBorder = border.setContext(context);
      const lineWidth = optsAtIndex.lineWidth;
      const lineColor = optsAtIndex.color;
      const borderDash = optsAtIndexBorder.dash || [];
      const borderDashOffset = optsAtIndexBorder.dashOffset;
      const tickWidth = optsAtIndex.tickWidth;
      const tickColor = optsAtIndex.tickColor;
      const tickBorderDash = optsAtIndex.tickBorderDash || [];
      const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;
      lineValue = getPixelForGridLine(this, i2, offset);
      if (lineValue === void 0) {
        continue;
      }
      alignedLineValue = _alignPixel(chart, lineValue, lineWidth);
      if (isHorizontal) {
        tx1 = tx2 = x1 = x2 = alignedLineValue;
      } else {
        ty1 = ty2 = y1 = y2 = alignedLineValue;
      }
      items.push({
        tx1,
        ty1,
        tx2,
        ty2,
        x1,
        y1,
        x2,
        y2,
        width: lineWidth,
        color: lineColor,
        borderDash,
        borderDashOffset,
        tickWidth,
        tickColor,
        tickBorderDash,
        tickBorderDashOffset
      });
    }
    this._ticksLength = ticksLength;
    this._borderValue = borderValue;
    return items;
  }
  _computeLabelItems(chartArea) {
    const axis = this.axis;
    const options = this.options;
    const { position, ticks: optionTicks } = options;
    const isHorizontal = this.isHorizontal();
    const ticks = this.ticks;
    const { align, crossAlign, padding, mirror } = optionTicks;
    const tl = getTickMarkLength(options.grid);
    const tickAndPadding = tl + padding;
    const hTickAndPadding = mirror ? -padding : tickAndPadding;
    const rotation = -toRadians(this.labelRotation);
    const items = [];
    let i2, ilen, tick, label, x2, y2, textAlign, pixel, font, lineHeight, lineCount, textOffset;
    let textBaseline = "middle";
    if (position === "top") {
      y2 = this.bottom - hTickAndPadding;
      textAlign = this._getXAxisLabelAlignment();
    } else if (position === "bottom") {
      y2 = this.top + hTickAndPadding;
      textAlign = this._getXAxisLabelAlignment();
    } else if (position === "left") {
      const ret = this._getYAxisLabelAlignment(tl);
      textAlign = ret.textAlign;
      x2 = ret.x;
    } else if (position === "right") {
      const ret = this._getYAxisLabelAlignment(tl);
      textAlign = ret.textAlign;
      x2 = ret.x;
    } else if (axis === "x") {
      if (position === "center") {
        y2 = (chartArea.top + chartArea.bottom) / 2 + tickAndPadding;
      } else if (isObject(position)) {
        const positionAxisID = Object.keys(position)[0];
        const value = position[positionAxisID];
        y2 = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;
      }
      textAlign = this._getXAxisLabelAlignment();
    } else if (axis === "y") {
      if (position === "center") {
        x2 = (chartArea.left + chartArea.right) / 2 - tickAndPadding;
      } else if (isObject(position)) {
        const positionAxisID = Object.keys(position)[0];
        const value = position[positionAxisID];
        x2 = this.chart.scales[positionAxisID].getPixelForValue(value);
      }
      textAlign = this._getYAxisLabelAlignment(tl).textAlign;
    }
    if (axis === "y") {
      if (align === "start") {
        textBaseline = "top";
      } else if (align === "end") {
        textBaseline = "bottom";
      }
    }
    const labelSizes = this._getLabelSizes();
    for (i2 = 0, ilen = ticks.length; i2 < ilen; ++i2) {
      tick = ticks[i2];
      label = tick.label;
      const optsAtIndex = optionTicks.setContext(this.getContext(i2));
      pixel = this.getPixelForTick(i2) + optionTicks.labelOffset;
      font = this._resolveTickFontOptions(i2);
      lineHeight = font.lineHeight;
      lineCount = isArray(label) ? label.length : 1;
      const halfCount = lineCount / 2;
      const color2 = optsAtIndex.color;
      const strokeColor = optsAtIndex.textStrokeColor;
      const strokeWidth = optsAtIndex.textStrokeWidth;
      let tickTextAlign = textAlign;
      if (isHorizontal) {
        x2 = pixel;
        if (textAlign === "inner") {
          if (i2 === ilen - 1) {
            tickTextAlign = !this.options.reverse ? "right" : "left";
          } else if (i2 === 0) {
            tickTextAlign = !this.options.reverse ? "left" : "right";
          } else {
            tickTextAlign = "center";
          }
        }
        if (position === "top") {
          if (crossAlign === "near" || rotation !== 0) {
            textOffset = -lineCount * lineHeight + lineHeight / 2;
          } else if (crossAlign === "center") {
            textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;
          } else {
            textOffset = -labelSizes.highest.height + lineHeight / 2;
          }
        } else {
          if (crossAlign === "near" || rotation !== 0) {
            textOffset = lineHeight / 2;
          } else if (crossAlign === "center") {
            textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;
          } else {
            textOffset = labelSizes.highest.height - lineCount * lineHeight;
          }
        }
        if (mirror) {
          textOffset *= -1;
        }
        if (rotation !== 0 && !optsAtIndex.showLabelBackdrop) {
          x2 += lineHeight / 2 * Math.sin(rotation);
        }
      } else {
        y2 = pixel;
        textOffset = (1 - lineCount) * lineHeight / 2;
      }
      let backdrop;
      if (optsAtIndex.showLabelBackdrop) {
        const labelPadding = toPadding(optsAtIndex.backdropPadding);
        const height = labelSizes.heights[i2];
        const width = labelSizes.widths[i2];
        let top = textOffset - labelPadding.top;
        let left = 0 - labelPadding.left;
        switch (textBaseline) {
          case "middle":
            top -= height / 2;
            break;
          case "bottom":
            top -= height;
            break;
        }
        switch (textAlign) {
          case "center":
            left -= width / 2;
            break;
          case "right":
            left -= width;
            break;
          case "inner":
            if (i2 === ilen - 1) {
              left -= width;
            } else if (i2 > 0) {
              left -= width / 2;
            }
            break;
        }
        backdrop = {
          left,
          top,
          width: width + labelPadding.width,
          height: height + labelPadding.height,
          color: optsAtIndex.backdropColor
        };
      }
      items.push({
        label,
        font,
        textOffset,
        options: {
          rotation,
          color: color2,
          strokeColor,
          strokeWidth,
          textAlign: tickTextAlign,
          textBaseline,
          translation: [
            x2,
            y2
          ],
          backdrop
        }
      });
    }
    return items;
  }
  _getXAxisLabelAlignment() {
    const { position, ticks } = this.options;
    const rotation = -toRadians(this.labelRotation);
    if (rotation) {
      return position === "top" ? "left" : "right";
    }
    let align = "center";
    if (ticks.align === "start") {
      align = "left";
    } else if (ticks.align === "end") {
      align = "right";
    } else if (ticks.align === "inner") {
      align = "inner";
    }
    return align;
  }
  _getYAxisLabelAlignment(tl) {
    const { position, ticks: { crossAlign, mirror, padding } } = this.options;
    const labelSizes = this._getLabelSizes();
    const tickAndPadding = tl + padding;
    const widest = labelSizes.widest.width;
    let textAlign;
    let x2;
    if (position === "left") {
      if (mirror) {
        x2 = this.right + padding;
        if (crossAlign === "near") {
          textAlign = "left";
        } else if (crossAlign === "center") {
          textAlign = "center";
          x2 += widest / 2;
        } else {
          textAlign = "right";
          x2 += widest;
        }
      } else {
        x2 = this.right - tickAndPadding;
        if (crossAlign === "near") {
          textAlign = "right";
        } else if (crossAlign === "center") {
          textAlign = "center";
          x2 -= widest / 2;
        } else {
          textAlign = "left";
          x2 = this.left;
        }
      }
    } else if (position === "right") {
      if (mirror) {
        x2 = this.left + padding;
        if (crossAlign === "near") {
          textAlign = "right";
        } else if (crossAlign === "center") {
          textAlign = "center";
          x2 -= widest / 2;
        } else {
          textAlign = "left";
          x2 -= widest;
        }
      } else {
        x2 = this.left + tickAndPadding;
        if (crossAlign === "near") {
          textAlign = "left";
        } else if (crossAlign === "center") {
          textAlign = "center";
          x2 += widest / 2;
        } else {
          textAlign = "right";
          x2 = this.right;
        }
      }
    } else {
      textAlign = "right";
    }
    return {
      textAlign,
      x: x2
    };
  }
  _computeLabelArea() {
    if (this.options.ticks.mirror) {
      return;
    }
    const chart = this.chart;
    const position = this.options.position;
    if (position === "left" || position === "right") {
      return {
        top: 0,
        left: this.left,
        bottom: chart.height,
        right: this.right
      };
    }
    if (position === "top" || position === "bottom") {
      return {
        top: this.top,
        left: 0,
        bottom: this.bottom,
        right: chart.width
      };
    }
  }
  drawBackground() {
    const { ctx, options: { backgroundColor }, left, top, width, height } = this;
    if (backgroundColor) {
      ctx.save();
      ctx.fillStyle = backgroundColor;
      ctx.fillRect(left, top, width, height);
      ctx.restore();
    }
  }
  getLineWidthForValue(value) {
    const grid = this.options.grid;
    if (!this._isVisible() || !grid.display) {
      return 0;
    }
    const ticks = this.ticks;
    const index = ticks.findIndex((t3) => t3.value === value);
    if (index >= 0) {
      const opts = grid.setContext(this.getContext(index));
      return opts.lineWidth;
    }
    return 0;
  }
  drawGrid(chartArea) {
    const grid = this.options.grid;
    const ctx = this.ctx;
    const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));
    let i2, ilen;
    const drawLine = (p1, p2, style) => {
      if (!style.width || !style.color) {
        return;
      }
      ctx.save();
      ctx.lineWidth = style.width;
      ctx.strokeStyle = style.color;
      ctx.setLineDash(style.borderDash || []);
      ctx.lineDashOffset = style.borderDashOffset;
      ctx.beginPath();
      ctx.moveTo(p1.x, p1.y);
      ctx.lineTo(p2.x, p2.y);
      ctx.stroke();
      ctx.restore();
    };
    if (grid.display) {
      for (i2 = 0, ilen = items.length; i2 < ilen; ++i2) {
        const item = items[i2];
        if (grid.drawOnChartArea) {
          drawLine({
            x: item.x1,
            y: item.y1
          }, {
            x: item.x2,
            y: item.y2
          }, item);
        }
        if (grid.drawTicks) {
          drawLine({
            x: item.tx1,
            y: item.ty1
          }, {
            x: item.tx2,
            y: item.ty2
          }, {
            color: item.tickColor,
            width: item.tickWidth,
            borderDash: item.tickBorderDash,
            borderDashOffset: item.tickBorderDashOffset
          });
        }
      }
    }
  }
  drawBorder() {
    const { chart, ctx, options: { border, grid } } = this;
    const borderOpts = border.setContext(this.getContext());
    const axisWidth = border.display ? borderOpts.width : 0;
    if (!axisWidth) {
      return;
    }
    const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;
    const borderValue = this._borderValue;
    let x1, x2, y1, y2;
    if (this.isHorizontal()) {
      x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;
      x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;
      y1 = y2 = borderValue;
    } else {
      y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;
      y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;
      x1 = x2 = borderValue;
    }
    ctx.save();
    ctx.lineWidth = borderOpts.width;
    ctx.strokeStyle = borderOpts.color;
    ctx.beginPath();
    ctx.moveTo(x1, y1);
    ctx.lineTo(x2, y2);
    ctx.stroke();
    ctx.restore();
  }
  drawLabels(chartArea) {
    const optionTicks = this.options.ticks;
    if (!optionTicks.display) {
      return;
    }
    const ctx = this.ctx;
    const area = this._computeLabelArea();
    if (area) {
      clipArea(ctx, area);
    }
    const items = this.getLabelItems(chartArea);
    for (const item of items) {
      const renderTextOptions = item.options;
      const tickFont = item.font;
      const label = item.label;
      const y2 = item.textOffset;
      renderText(ctx, label, 0, y2, tickFont, renderTextOptions);
    }
    if (area) {
      unclipArea(ctx);
    }
  }
  drawTitle() {
    const { ctx, options: { position, title, reverse } } = this;
    if (!title.display) {
      return;
    }
    const font = toFont(title.font);
    const padding = toPadding(title.padding);
    const align = title.align;
    let offset = font.lineHeight / 2;
    if (position === "bottom" || position === "center" || isObject(position)) {
      offset += padding.bottom;
      if (isArray(title.text)) {
        offset += font.lineHeight * (title.text.length - 1);
      }
    } else {
      offset += padding.top;
    }
    const { titleX, titleY, maxWidth, rotation } = titleArgs(this, offset, position, align);
    renderText(ctx, title.text, 0, 0, font, {
      color: title.color,
      maxWidth,
      rotation,
      textAlign: titleAlign(align, position, reverse),
      textBaseline: "middle",
      translation: [
        titleX,
        titleY
      ]
    });
  }
  draw(chartArea) {
    if (!this._isVisible()) {
      return;
    }
    this.drawBackground();
    this.drawGrid(chartArea);
    this.drawBorder();
    this.drawTitle();
    this.drawLabels(chartArea);
  }
  _layers() {
    const opts = this.options;
    const tz = opts.ticks && opts.ticks.z || 0;
    const gz = valueOrDefault(opts.grid && opts.grid.z, -1);
    const bz = valueOrDefault(opts.border && opts.border.z, 0);
    if (!this._isVisible() || this.draw !== _Scale.prototype.draw) {
      return [
        {
          z: tz,
          draw: (chartArea) => {
            this.draw(chartArea);
          }
        }
      ];
    }
    return [
      {
        z: gz,
        draw: (chartArea) => {
          this.drawBackground();
          this.drawGrid(chartArea);
          this.drawTitle();
        }
      },
      {
        z: bz,
        draw: () => {
          this.drawBorder();
        }
      },
      {
        z: tz,
        draw: (chartArea) => {
          this.drawLabels(chartArea);
        }
      }
    ];
  }
  getMatchingVisibleMetas(type) {
    const metas = this.chart.getSortedVisibleDatasetMetas();
    const axisID = this.axis + "AxisID";
    const result = [];
    let i2, ilen;
    for (i2 = 0, ilen = metas.length; i2 < ilen; ++i2) {
      const meta = metas[i2];
      if (meta[axisID] === this.id && (!type || meta.type === type)) {
        result.push(meta);
      }
    }
    return result;
  }
  _resolveTickFontOptions(index) {
    const opts = this.options.ticks.setContext(this.getContext(index));
    return toFont(opts.font);
  }
  _maxDigits() {
    const fontSize = this._resolveTickFontOptions(0).lineHeight;
    return (this.isHorizontal() ? this.width : this.height) / fontSize;
  }
};
var TypedRegistry = class {
  constructor(type, scope, override) {
    this.type = type;
    this.scope = scope;
    this.override = override;
    this.items = /* @__PURE__ */ Object.create(null);
  }
  isForType(type) {
    return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);
  }
  register(item) {
    const proto = Object.getPrototypeOf(item);
    let parentScope;
    if (isIChartComponent(proto)) {
      parentScope = this.register(proto);
    }
    const items = this.items;
    const id2 = item.id;
    const scope = this.scope + "." + id2;
    if (!id2) {
      throw new Error("class does not have id: " + item);
    }
    if (id2 in items) {
      return scope;
    }
    items[id2] = item;
    registerDefaults(item, scope, parentScope);
    if (this.override) {
      defaults2.override(item.id, item.overrides);
    }
    return scope;
  }
  get(id2) {
    return this.items[id2];
  }
  unregister(item) {
    const items = this.items;
    const id2 = item.id;
    const scope = this.scope;
    if (id2 in items) {
      delete items[id2];
    }
    if (scope && id2 in defaults2[scope]) {
      delete defaults2[scope][id2];
      if (this.override) {
        delete overrides[id2];
      }
    }
  }
};
function registerDefaults(item, scope, parentScope) {
  const itemDefaults = merge(/* @__PURE__ */ Object.create(null), [
    parentScope ? defaults2.get(parentScope) : {},
    defaults2.get(scope),
    item.defaults
  ]);
  defaults2.set(scope, itemDefaults);
  if (item.defaultRoutes) {
    routeDefaults(scope, item.defaultRoutes);
  }
  if (item.descriptors) {
    defaults2.describe(scope, item.descriptors);
  }
}
function routeDefaults(scope, routes) {
  Object.keys(routes).forEach((property) => {
    const propertyParts = property.split(".");
    const sourceName = propertyParts.pop();
    const sourceScope = [
      scope
    ].concat(propertyParts).join(".");
    const parts = routes[property].split(".");
    const targetName = parts.pop();
    const targetScope = parts.join(".");
    defaults2.route(sourceScope, sourceName, targetScope, targetName);
  });
}
function isIChartComponent(proto) {
  return "id" in proto && "defaults" in proto;
}
var Registry = class {
  constructor() {
    this.controllers = new TypedRegistry(DatasetController, "datasets", true);
    this.elements = new TypedRegistry(Element, "elements");
    this.plugins = new TypedRegistry(Object, "plugins");
    this.scales = new TypedRegistry(Scale, "scales");
    this._typedRegistries = [
      this.controllers,
      this.scales,
      this.elements
    ];
  }
  add(...args) {
    this._each("register", args);
  }
  remove(...args) {
    this._each("unregister", args);
  }
  addControllers(...args) {
    this._each("register", args, this.controllers);
  }
  addElements(...args) {
    this._each("register", args, this.elements);
  }
  addPlugins(...args) {
    this._each("register", args, this.plugins);
  }
  addScales(...args) {
    this._each("register", args, this.scales);
  }
  getController(id2) {
    return this._get(id2, this.controllers, "controller");
  }
  getElement(id2) {
    return this._get(id2, this.elements, "element");
  }
  getPlugin(id2) {
    return this._get(id2, this.plugins, "plugin");
  }
  getScale(id2) {
    return this._get(id2, this.scales, "scale");
  }
  removeControllers(...args) {
    this._each("unregister", args, this.controllers);
  }
  removeElements(...args) {
    this._each("unregister", args, this.elements);
  }
  removePlugins(...args) {
    this._each("unregister", args, this.plugins);
  }
  removeScales(...args) {
    this._each("unregister", args, this.scales);
  }
  _each(method, args, typedRegistry) {
    [
      ...args
    ].forEach((arg) => {
      const reg = typedRegistry || this._getRegistryForType(arg);
      if (typedRegistry || reg.isForType(arg) || reg === this.plugins && arg.id) {
        this._exec(method, reg, arg);
      } else {
        each(arg, (item) => {
          const itemReg = typedRegistry || this._getRegistryForType(item);
          this._exec(method, itemReg, item);
        });
      }
    });
  }
  _exec(method, registry2, component) {
    const camelMethod = _capitalize(method);
    callback(component["before" + camelMethod], [], component);
    registry2[method](component);
    callback(component["after" + camelMethod], [], component);
  }
  _getRegistryForType(type) {
    for (let i2 = 0; i2 < this._typedRegistries.length; i2++) {
      const reg = this._typedRegistries[i2];
      if (reg.isForType(type)) {
        return reg;
      }
    }
    return this.plugins;
  }
  _get(id2, typedRegistry, type) {
    const item = typedRegistry.get(id2);
    if (item === void 0) {
      throw new Error('"' + id2 + '" is not a registered ' + type + ".");
    }
    return item;
  }
};
var registry = /* @__PURE__ */ new Registry();
var PluginService = class {
  constructor() {
    this._init = void 0;
  }
  notify(chart, hook, args, filter2) {
    if (hook === "beforeInit") {
      this._init = this._createDescriptors(chart, true);
      this._notify(this._init, chart, "install");
    }
    if (this._init === void 0) {
      return;
    }
    const descriptors2 = filter2 ? this._descriptors(chart).filter(filter2) : this._descriptors(chart);
    const result = this._notify(descriptors2, chart, hook, args);
    if (hook === "afterDestroy") {
      this._notify(descriptors2, chart, "stop");
      this._notify(this._init, chart, "uninstall");
      this._init = void 0;
    }
    return result;
  }
  _notify(descriptors2, chart, hook, args) {
    args = args || {};
    for (const descriptor of descriptors2) {
      const plugin = descriptor.plugin;
      const method = plugin[hook];
      const params = [
        chart,
        args,
        descriptor.options
      ];
      if (callback(method, params, plugin) === false && args.cancelable) {
        return false;
      }
    }
    return true;
  }
  invalidate() {
    if (!isNullOrUndef(this._cache)) {
      this._oldCache = this._cache;
      this._cache = void 0;
    }
  }
  _descriptors(chart) {
    if (this._cache) {
      return this._cache;
    }
    const descriptors2 = this._cache = this._createDescriptors(chart);
    this._notifyStateChanges(chart);
    return descriptors2;
  }
  _createDescriptors(chart, all) {
    const config = chart && chart.config;
    const options = valueOrDefault(config.options && config.options.plugins, {});
    const plugins = allPlugins(config);
    return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);
  }
  _notifyStateChanges(chart) {
    const previousDescriptors = this._oldCache || [];
    const descriptors2 = this._cache;
    const diff = (a2, b2) => a2.filter((x2) => !b2.some((y2) => x2.plugin.id === y2.plugin.id));
    this._notify(diff(previousDescriptors, descriptors2), chart, "stop");
    this._notify(diff(descriptors2, previousDescriptors), chart, "start");
  }
};
function allPlugins(config) {
  const localIds = {};
  const plugins = [];
  const keys = Object.keys(registry.plugins.items);
  for (let i2 = 0; i2 < keys.length; i2++) {
    plugins.push(registry.getPlugin(keys[i2]));
  }
  const local = config.plugins || [];
  for (let i2 = 0; i2 < local.length; i2++) {
    const plugin = local[i2];
    if (plugins.indexOf(plugin) === -1) {
      plugins.push(plugin);
      localIds[plugin.id] = true;
    }
  }
  return {
    plugins,
    localIds
  };
}
function getOpts(options, all) {
  if (!all && options === false) {
    return null;
  }
  if (options === true) {
    return {};
  }
  return options;
}
function createDescriptors(chart, { plugins, localIds }, options, all) {
  const result = [];
  const context = chart.getContext();
  for (const plugin of plugins) {
    const id2 = plugin.id;
    const opts = getOpts(options[id2], all);
    if (opts === null) {
      continue;
    }
    result.push({
      plugin,
      options: pluginOpts(chart.config, {
        plugin,
        local: localIds[id2]
      }, opts, context)
    });
  }
  return result;
}
function pluginOpts(config, { plugin, local }, opts, context) {
  const keys = config.pluginScopeKeys(plugin);
  const scopes = config.getOptionScopes(opts, keys);
  if (local && plugin.defaults) {
    scopes.push(plugin.defaults);
  }
  return config.createResolver(scopes, context, [
    ""
  ], {
    scriptable: false,
    indexable: false,
    allKeys: true
  });
}
function getIndexAxis(type, options) {
  const datasetDefaults = defaults2.datasets[type] || {};
  const datasetOptions = (options.datasets || {})[type] || {};
  return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || "x";
}
function getAxisFromDefaultScaleID(id2, indexAxis) {
  let axis = id2;
  if (id2 === "_index_") {
    axis = indexAxis;
  } else if (id2 === "_value_") {
    axis = indexAxis === "x" ? "y" : "x";
  }
  return axis;
}
function getDefaultScaleIDFromAxis(axis, indexAxis) {
  return axis === indexAxis ? "_index_" : "_value_";
}
function idMatchesAxis(id2) {
  if (id2 === "x" || id2 === "y" || id2 === "r") {
    return id2;
  }
}
function axisFromPosition(position) {
  if (position === "top" || position === "bottom") {
    return "x";
  }
  if (position === "left" || position === "right") {
    return "y";
  }
}
function determineAxis(id2, ...scaleOptions) {
  if (idMatchesAxis(id2)) {
    return id2;
  }
  for (const opts of scaleOptions) {
    const axis = opts.axis || axisFromPosition(opts.position) || id2.length > 1 && idMatchesAxis(id2[0].toLowerCase());
    if (axis) {
      return axis;
    }
  }
  throw new Error(`Cannot determine type of '${id2}' axis. Please provide 'axis' or 'position' option.`);
}
function getAxisFromDataset(id2, axis, dataset) {
  if (dataset[axis + "AxisID"] === id2) {
    return {
      axis
    };
  }
}
function retrieveAxisFromDatasets(id2, config) {
  if (config.data && config.data.datasets) {
    const boundDs = config.data.datasets.filter((d2) => d2.xAxisID === id2 || d2.yAxisID === id2);
    if (boundDs.length) {
      return getAxisFromDataset(id2, "x", boundDs[0]) || getAxisFromDataset(id2, "y", boundDs[0]);
    }
  }
  return {};
}
function mergeScaleConfig(config, options) {
  const chartDefaults = overrides[config.type] || {
    scales: {}
  };
  const configScales = options.scales || {};
  const chartIndexAxis = getIndexAxis(config.type, options);
  const scales = /* @__PURE__ */ Object.create(null);
  Object.keys(configScales).forEach((id2) => {
    const scaleConf = configScales[id2];
    if (!isObject(scaleConf)) {
      return console.error(`Invalid scale configuration for scale: ${id2}`);
    }
    if (scaleConf._proxy) {
      return console.warn(`Ignoring resolver passed as options for scale: ${id2}`);
    }
    const axis = determineAxis(id2, scaleConf, retrieveAxisFromDatasets(id2, config), defaults2.scales[scaleConf.type]);
    const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);
    const defaultScaleOptions = chartDefaults.scales || {};
    scales[id2] = mergeIf(/* @__PURE__ */ Object.create(null), [
      {
        axis
      },
      scaleConf,
      defaultScaleOptions[axis],
      defaultScaleOptions[defaultId]
    ]);
  });
  config.data.datasets.forEach((dataset) => {
    const type = dataset.type || config.type;
    const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
    const datasetDefaults = overrides[type] || {};
    const defaultScaleOptions = datasetDefaults.scales || {};
    Object.keys(defaultScaleOptions).forEach((defaultID) => {
      const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);
      const id2 = dataset[axis + "AxisID"] || axis;
      scales[id2] = scales[id2] || /* @__PURE__ */ Object.create(null);
      mergeIf(scales[id2], [
        {
          axis
        },
        configScales[id2],
        defaultScaleOptions[defaultID]
      ]);
    });
  });
  Object.keys(scales).forEach((key) => {
    const scale = scales[key];
    mergeIf(scale, [
      defaults2.scales[scale.type],
      defaults2.scale
    ]);
  });
  return scales;
}
function initOptions(config) {
  const options = config.options || (config.options = {});
  options.plugins = valueOrDefault(options.plugins, {});
  options.scales = mergeScaleConfig(config, options);
}
function initData(data) {
  data = data || {};
  data.datasets = data.datasets || [];
  data.labels = data.labels || [];
  return data;
}
function initConfig(config) {
  config = config || {};
  config.data = initData(config.data);
  initOptions(config);
  return config;
}
var keyCache = /* @__PURE__ */ new Map();
var keysCached = /* @__PURE__ */ new Set();
function cachedKeys(cacheKey, generate) {
  let keys = keyCache.get(cacheKey);
  if (!keys) {
    keys = generate();
    keyCache.set(cacheKey, keys);
    keysCached.add(keys);
  }
  return keys;
}
var addIfFound = (set2, obj, key) => {
  const opts = resolveObjectKey(obj, key);
  if (opts !== void 0) {
    set2.add(opts);
  }
};
var Config = class {
  constructor(config) {
    this._config = initConfig(config);
    this._scopeCache = /* @__PURE__ */ new Map();
    this._resolverCache = /* @__PURE__ */ new Map();
  }
  get platform() {
    return this._config.platform;
  }
  get type() {
    return this._config.type;
  }
  set type(type) {
    this._config.type = type;
  }
  get data() {
    return this._config.data;
  }
  set data(data) {
    this._config.data = initData(data);
  }
  get options() {
    return this._config.options;
  }
  set options(options) {
    this._config.options = options;
  }
  get plugins() {
    return this._config.plugins;
  }
  update() {
    const config = this._config;
    this.clearCache();
    initOptions(config);
  }
  clearCache() {
    this._scopeCache.clear();
    this._resolverCache.clear();
  }
  datasetScopeKeys(datasetType) {
    return cachedKeys(datasetType, () => [
      [
        `datasets.${datasetType}`,
        ""
      ]
    ]);
  }
  datasetAnimationScopeKeys(datasetType, transition) {
    return cachedKeys(`${datasetType}.transition.${transition}`, () => [
      [
        `datasets.${datasetType}.transitions.${transition}`,
        `transitions.${transition}`
      ],
      [
        `datasets.${datasetType}`,
        ""
      ]
    ]);
  }
  datasetElementScopeKeys(datasetType, elementType) {
    return cachedKeys(`${datasetType}-${elementType}`, () => [
      [
        `datasets.${datasetType}.elements.${elementType}`,
        `datasets.${datasetType}`,
        `elements.${elementType}`,
        ""
      ]
    ]);
  }
  pluginScopeKeys(plugin) {
    const id2 = plugin.id;
    const type = this.type;
    return cachedKeys(`${type}-plugin-${id2}`, () => [
      [
        `plugins.${id2}`,
        ...plugin.additionalOptionScopes || []
      ]
    ]);
  }
  _cachedScopes(mainScope, resetCache) {
    const _scopeCache = this._scopeCache;
    let cache = _scopeCache.get(mainScope);
    if (!cache || resetCache) {
      cache = /* @__PURE__ */ new Map();
      _scopeCache.set(mainScope, cache);
    }
    return cache;
  }
  getOptionScopes(mainScope, keyLists, resetCache) {
    const { options, type } = this;
    const cache = this._cachedScopes(mainScope, resetCache);
    const cached = cache.get(keyLists);
    if (cached) {
      return cached;
    }
    const scopes = /* @__PURE__ */ new Set();
    keyLists.forEach((keys) => {
      if (mainScope) {
        scopes.add(mainScope);
        keys.forEach((key) => addIfFound(scopes, mainScope, key));
      }
      keys.forEach((key) => addIfFound(scopes, options, key));
      keys.forEach((key) => addIfFound(scopes, overrides[type] || {}, key));
      keys.forEach((key) => addIfFound(scopes, defaults2, key));
      keys.forEach((key) => addIfFound(scopes, descriptors, key));
    });
    const array = Array.from(scopes);
    if (array.length === 0) {
      array.push(/* @__PURE__ */ Object.create(null));
    }
    if (keysCached.has(keyLists)) {
      cache.set(keyLists, array);
    }
    return array;
  }
  chartOptionScopes() {
    const { options, type } = this;
    return [
      options,
      overrides[type] || {},
      defaults2.datasets[type] || {},
      {
        type
      },
      defaults2,
      descriptors
    ];
  }
  resolveNamedOptions(scopes, names2, context, prefixes = [
    ""
  ]) {
    const result = {
      $shared: true
    };
    const { resolver, subPrefixes } = getResolver(this._resolverCache, scopes, prefixes);
    let options = resolver;
    if (needContext(resolver, names2)) {
      result.$shared = false;
      context = isFunction(context) ? context() : context;
      const subResolver = this.createResolver(scopes, context, subPrefixes);
      options = _attachContext(resolver, context, subResolver);
    }
    for (const prop of names2) {
      result[prop] = options[prop];
    }
    return result;
  }
  createResolver(scopes, context, prefixes = [
    ""
  ], descriptorDefaults) {
    const { resolver } = getResolver(this._resolverCache, scopes, prefixes);
    return isObject(context) ? _attachContext(resolver, context, void 0, descriptorDefaults) : resolver;
  }
};
function getResolver(resolverCache, scopes, prefixes) {
  let cache = resolverCache.get(scopes);
  if (!cache) {
    cache = /* @__PURE__ */ new Map();
    resolverCache.set(scopes, cache);
  }
  const cacheKey = prefixes.join();
  let cached = cache.get(cacheKey);
  if (!cached) {
    const resolver = _createResolver(scopes, prefixes);
    cached = {
      resolver,
      subPrefixes: prefixes.filter((p2) => !p2.toLowerCase().includes("hover"))
    };
    cache.set(cacheKey, cached);
  }
  return cached;
}
var hasFunction = (value) => isObject(value) && Object.getOwnPropertyNames(value).some((key) => isFunction(value[key]));
function needContext(proxy, names2) {
  const { isScriptable, isIndexable } = _descriptors(proxy);
  for (const prop of names2) {
    const scriptable = isScriptable(prop);
    const indexable = isIndexable(prop);
    const value = (indexable || scriptable) && proxy[prop];
    if (scriptable && (isFunction(value) || hasFunction(value)) || indexable && isArray(value)) {
      return true;
    }
  }
  return false;
}
var version = "4.5.1";
var KNOWN_POSITIONS = [
  "top",
  "bottom",
  "left",
  "right",
  "chartArea"
];
function positionIsHorizontal(position, axis) {
  return position === "top" || position === "bottom" || KNOWN_POSITIONS.indexOf(position) === -1 && axis === "x";
}
function compare2Level(l1, l2) {
  return function(a2, b2) {
    return a2[l1] === b2[l1] ? a2[l2] - b2[l2] : a2[l1] - b2[l1];
  };
}
function onAnimationsComplete(context) {
  const chart = context.chart;
  const animationOptions = chart.options.animation;
  chart.notifyPlugins("afterRender");
  callback(animationOptions && animationOptions.onComplete, [
    context
  ], chart);
}
function onAnimationProgress(context) {
  const chart = context.chart;
  const animationOptions = chart.options.animation;
  callback(animationOptions && animationOptions.onProgress, [
    context
  ], chart);
}
function getCanvas(item) {
  if (_isDomSupported() && typeof item === "string") {
    item = document.getElementById(item);
  } else if (item && item.length) {
    item = item[0];
  }
  if (item && item.canvas) {
    item = item.canvas;
  }
  return item;
}
var instances = {};
var getChart = (key) => {
  const canvas = getCanvas(key);
  return Object.values(instances).filter((c2) => c2.canvas === canvas).pop();
};
function moveNumericKeys(obj, start, move) {
  const keys = Object.keys(obj);
  for (const key of keys) {
    const intKey = +key;
    if (intKey >= start) {
      const value = obj[key];
      delete obj[key];
      if (move > 0 || intKey > start) {
        obj[intKey + move] = value;
      }
    }
  }
}
function determineLastEvent(e2, lastEvent, inChartArea, isClick) {
  if (!inChartArea || e2.type === "mouseout") {
    return null;
  }
  if (isClick) {
    return lastEvent;
  }
  return e2;
}
var Chart = class {
  static register(...items) {
    registry.add(...items);
    invalidatePlugins();
  }
  static unregister(...items) {
    registry.remove(...items);
    invalidatePlugins();
  }
  constructor(item, userConfig) {
    const config = this.config = new Config(userConfig);
    const initialCanvas = getCanvas(item);
    const existingChart = getChart(initialCanvas);
    if (existingChart) {
      throw new Error("Canvas is already in use. Chart with ID '" + existingChart.id + "' must be destroyed before the canvas with ID '" + existingChart.canvas.id + "' can be reused.");
    }
    const options = config.createResolver(config.chartOptionScopes(), this.getContext());
    this.platform = new (config.platform || _detectPlatform(initialCanvas))();
    this.platform.updateConfig(config);
    const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);
    const canvas = context && context.canvas;
    const height = canvas && canvas.height;
    const width = canvas && canvas.width;
    this.id = uid();
    this.ctx = context;
    this.canvas = canvas;
    this.width = width;
    this.height = height;
    this._options = options;
    this._aspectRatio = this.aspectRatio;
    this._layers = [];
    this._metasets = [];
    this._stacks = void 0;
    this.boxes = [];
    this.currentDevicePixelRatio = void 0;
    this.chartArea = void 0;
    this._active = [];
    this._lastEvent = void 0;
    this._listeners = {};
    this._responsiveListeners = void 0;
    this._sortedMetasets = [];
    this.scales = {};
    this._plugins = new PluginService();
    this.$proxies = {};
    this._hiddenIndices = {};
    this.attached = false;
    this._animationsDisabled = void 0;
    this.$context = void 0;
    this._doResize = debounce((mode) => this.update(mode), options.resizeDelay || 0);
    this._dataChanges = [];
    instances[this.id] = this;
    if (!context || !canvas) {
      console.error("Failed to create chart: can't acquire context from the given item");
      return;
    }
    animator.listen(this, "complete", onAnimationsComplete);
    animator.listen(this, "progress", onAnimationProgress);
    this._initialize();
    if (this.attached) {
      this.update();
    }
  }
  get aspectRatio() {
    const { options: { aspectRatio, maintainAspectRatio }, width, height, _aspectRatio } = this;
    if (!isNullOrUndef(aspectRatio)) {
      return aspectRatio;
    }
    if (maintainAspectRatio && _aspectRatio) {
      return _aspectRatio;
    }
    return height ? width / height : null;
  }
  get data() {
    return this.config.data;
  }
  set data(data) {
    this.config.data = data;
  }
  get options() {
    return this._options;
  }
  set options(options) {
    this.config.options = options;
  }
  get registry() {
    return registry;
  }
  _initialize() {
    this.notifyPlugins("beforeInit");
    if (this.options.responsive) {
      this.resize();
    } else {
      retinaScale(this, this.options.devicePixelRatio);
    }
    this.bindEvents();
    this.notifyPlugins("afterInit");
    return this;
  }
  clear() {
    clearCanvas(this.canvas, this.ctx);
    return this;
  }
  stop() {
    animator.stop(this);
    return this;
  }
  resize(width, height) {
    if (!animator.running(this)) {
      this._resize(width, height);
    } else {
      this._resizeBeforeDraw = {
        width,
        height
      };
    }
  }
  _resize(width, height) {
    const options = this.options;
    const canvas = this.canvas;
    const aspectRatio = options.maintainAspectRatio && this.aspectRatio;
    const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);
    const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();
    const mode = this.width ? "resize" : "attach";
    this.width = newSize.width;
    this.height = newSize.height;
    this._aspectRatio = this.aspectRatio;
    if (!retinaScale(this, newRatio, true)) {
      return;
    }
    this.notifyPlugins("resize", {
      size: newSize
    });
    callback(options.onResize, [
      this,
      newSize
    ], this);
    if (this.attached) {
      if (this._doResize(mode)) {
        this.render();
      }
    }
  }
  ensureScalesHaveIDs() {
    const options = this.options;
    const scalesOptions = options.scales || {};
    each(scalesOptions, (axisOptions, axisID) => {
      axisOptions.id = axisID;
    });
  }
  buildOrUpdateScales() {
    const options = this.options;
    const scaleOpts = options.scales;
    const scales = this.scales;
    const updated = Object.keys(scales).reduce((obj, id2) => {
      obj[id2] = false;
      return obj;
    }, {});
    let items = [];
    if (scaleOpts) {
      items = items.concat(Object.keys(scaleOpts).map((id2) => {
        const scaleOptions = scaleOpts[id2];
        const axis = determineAxis(id2, scaleOptions);
        const isRadial = axis === "r";
        const isHorizontal = axis === "x";
        return {
          options: scaleOptions,
          dposition: isRadial ? "chartArea" : isHorizontal ? "bottom" : "left",
          dtype: isRadial ? "radialLinear" : isHorizontal ? "category" : "linear"
        };
      }));
    }
    each(items, (item) => {
      const scaleOptions = item.options;
      const id2 = scaleOptions.id;
      const axis = determineAxis(id2, scaleOptions);
      const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
      if (scaleOptions.position === void 0 || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {
        scaleOptions.position = item.dposition;
      }
      updated[id2] = true;
      let scale = null;
      if (id2 in scales && scales[id2].type === scaleType) {
        scale = scales[id2];
      } else {
        const scaleClass = registry.getScale(scaleType);
        scale = new scaleClass({
          id: id2,
          type: scaleType,
          ctx: this.ctx,
          chart: this
        });
        scales[scale.id] = scale;
      }
      scale.init(scaleOptions, options);
    });
    each(updated, (hasUpdated, id2) => {
      if (!hasUpdated) {
        delete scales[id2];
      }
    });
    each(scales, (scale) => {
      layouts.configure(this, scale, scale.options);
      layouts.addBox(this, scale);
    });
  }
  _updateMetasets() {
    const metasets = this._metasets;
    const numData = this.data.datasets.length;
    const numMeta = metasets.length;
    metasets.sort((a2, b2) => a2.index - b2.index);
    if (numMeta > numData) {
      for (let i2 = numData; i2 < numMeta; ++i2) {
        this._destroyDatasetMeta(i2);
      }
      metasets.splice(numData, numMeta - numData);
    }
    this._sortedMetasets = metasets.slice(0).sort(compare2Level("order", "index"));
  }
  _removeUnreferencedMetasets() {
    const { _metasets: metasets, data: { datasets } } = this;
    if (metasets.length > datasets.length) {
      delete this._stacks;
    }
    metasets.forEach((meta, index) => {
      if (datasets.filter((x2) => x2 === meta._dataset).length === 0) {
        this._destroyDatasetMeta(index);
      }
    });
  }
  buildOrUpdateControllers() {
    const newControllers = [];
    const datasets = this.data.datasets;
    let i2, ilen;
    this._removeUnreferencedMetasets();
    for (i2 = 0, ilen = datasets.length; i2 < ilen; i2++) {
      const dataset = datasets[i2];
      let meta = this.getDatasetMeta(i2);
      const type = dataset.type || this.config.type;
      if (meta.type && meta.type !== type) {
        this._destroyDatasetMeta(i2);
        meta = this.getDatasetMeta(i2);
      }
      meta.type = type;
      meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);
      meta.order = dataset.order || 0;
      meta.index = i2;
      meta.label = "" + dataset.label;
      meta.visible = this.isDatasetVisible(i2);
      if (meta.controller) {
        meta.controller.updateIndex(i2);
        meta.controller.linkScales();
      } else {
        const ControllerClass = registry.getController(type);
        const { datasetElementType, dataElementType } = defaults2.datasets[type];
        Object.assign(ControllerClass, {
          dataElementType: registry.getElement(dataElementType),
          datasetElementType: datasetElementType && registry.getElement(datasetElementType)
        });
        meta.controller = new ControllerClass(this, i2);
        newControllers.push(meta.controller);
      }
    }
    this._updateMetasets();
    return newControllers;
  }
  _resetElements() {
    each(this.data.datasets, (dataset, datasetIndex) => {
      this.getDatasetMeta(datasetIndex).controller.reset();
    }, this);
  }
  reset() {
    this._resetElements();
    this.notifyPlugins("reset");
  }
  update(mode) {
    const config = this.config;
    config.update();
    const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
    const animsDisabled = this._animationsDisabled = !options.animation;
    this._updateScales();
    this._checkEventBindings();
    this._updateHiddenIndices();
    this._plugins.invalidate();
    if (this.notifyPlugins("beforeUpdate", {
      mode,
      cancelable: true
    }) === false) {
      return;
    }
    const newControllers = this.buildOrUpdateControllers();
    this.notifyPlugins("beforeElementsUpdate");
    let minPadding = 0;
    for (let i2 = 0, ilen = this.data.datasets.length; i2 < ilen; i2++) {
      const { controller } = this.getDatasetMeta(i2);
      const reset2 = !animsDisabled && newControllers.indexOf(controller) === -1;
      controller.buildOrUpdateElements(reset2);
      minPadding = Math.max(+controller.getMaxOverflow(), minPadding);
    }
    minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;
    this._updateLayout(minPadding);
    if (!animsDisabled) {
      each(newControllers, (controller) => {
        controller.reset();
      });
    }
    this._updateDatasets(mode);
    this.notifyPlugins("afterUpdate", {
      mode
    });
    this._layers.sort(compare2Level("z", "_idx"));
    const { _active, _lastEvent } = this;
    if (_lastEvent) {
      this._eventHandler(_lastEvent, true);
    } else if (_active.length) {
      this._updateHoverStyles(_active, _active, true);
    }
    this.render();
  }
  _updateScales() {
    each(this.scales, (scale) => {
      layouts.removeBox(this, scale);
    });
    this.ensureScalesHaveIDs();
    this.buildOrUpdateScales();
  }
  _checkEventBindings() {
    const options = this.options;
    const existingEvents = new Set(Object.keys(this._listeners));
    const newEvents = new Set(options.events);
    if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
      this.unbindEvents();
      this.bindEvents();
    }
  }
  _updateHiddenIndices() {
    const { _hiddenIndices } = this;
    const changes = this._getUniformDataChanges() || [];
    for (const { method, start, count } of changes) {
      const move = method === "_removeElements" ? -count : count;
      moveNumericKeys(_hiddenIndices, start, move);
    }
  }
  _getUniformDataChanges() {
    const _dataChanges = this._dataChanges;
    if (!_dataChanges || !_dataChanges.length) {
      return;
    }
    this._dataChanges = [];
    const datasetCount = this.data.datasets.length;
    const makeSet = (idx) => new Set(_dataChanges.filter((c2) => c2[0] === idx).map((c2, i2) => i2 + "," + c2.splice(1).join(",")));
    const changeSet = makeSet(0);
    for (let i2 = 1; i2 < datasetCount; i2++) {
      if (!setsEqual(changeSet, makeSet(i2))) {
        return;
      }
    }
    return Array.from(changeSet).map((c2) => c2.split(",")).map((a2) => ({
      method: a2[1],
      start: +a2[2],
      count: +a2[3]
    }));
  }
  _updateLayout(minPadding) {
    if (this.notifyPlugins("beforeLayout", {
      cancelable: true
    }) === false) {
      return;
    }
    layouts.update(this, this.width, this.height, minPadding);
    const area = this.chartArea;
    const noArea = area.width <= 0 || area.height <= 0;
    this._layers = [];
    each(this.boxes, (box) => {
      if (noArea && box.position === "chartArea") {
        return;
      }
      if (box.configure) {
        box.configure();
      }
      this._layers.push(...box._layers());
    }, this);
    this._layers.forEach((item, index) => {
      item._idx = index;
    });
    this.notifyPlugins("afterLayout");
  }
  _updateDatasets(mode) {
    if (this.notifyPlugins("beforeDatasetsUpdate", {
      mode,
      cancelable: true
    }) === false) {
      return;
    }
    for (let i2 = 0, ilen = this.data.datasets.length; i2 < ilen; ++i2) {
      this.getDatasetMeta(i2).controller.configure();
    }
    for (let i2 = 0, ilen = this.data.datasets.length; i2 < ilen; ++i2) {
      this._updateDataset(i2, isFunction(mode) ? mode({
        datasetIndex: i2
      }) : mode);
    }
    this.notifyPlugins("afterDatasetsUpdate", {
      mode
    });
  }
  _updateDataset(index, mode) {
    const meta = this.getDatasetMeta(index);
    const args = {
      meta,
      index,
      mode,
      cancelable: true
    };
    if (this.notifyPlugins("beforeDatasetUpdate", args) === false) {
      return;
    }
    meta.controller._update(mode);
    args.cancelable = false;
    this.notifyPlugins("afterDatasetUpdate", args);
  }
  render() {
    if (this.notifyPlugins("beforeRender", {
      cancelable: true
    }) === false) {
      return;
    }
    if (animator.has(this)) {
      if (this.attached && !animator.running(this)) {
        animator.start(this);
      }
    } else {
      this.draw();
      onAnimationsComplete({
        chart: this
      });
    }
  }
  draw() {
    let i2;
    if (this._resizeBeforeDraw) {
      const { width, height } = this._resizeBeforeDraw;
      this._resizeBeforeDraw = null;
      this._resize(width, height);
    }
    this.clear();
    if (this.width <= 0 || this.height <= 0) {
      return;
    }
    if (this.notifyPlugins("beforeDraw", {
      cancelable: true
    }) === false) {
      return;
    }
    const layers = this._layers;
    for (i2 = 0; i2 < layers.length && layers[i2].z <= 0; ++i2) {
      layers[i2].draw(this.chartArea);
    }
    this._drawDatasets();
    for (; i2 < layers.length; ++i2) {
      layers[i2].draw(this.chartArea);
    }
    this.notifyPlugins("afterDraw");
  }
  _getSortedDatasetMetas(filterVisible) {
    const metasets = this._sortedMetasets;
    const result = [];
    let i2, ilen;
    for (i2 = 0, ilen = metasets.length; i2 < ilen; ++i2) {
      const meta = metasets[i2];
      if (!filterVisible || meta.visible) {
        result.push(meta);
      }
    }
    return result;
  }
  getSortedVisibleDatasetMetas() {
    return this._getSortedDatasetMetas(true);
  }
  _drawDatasets() {
    if (this.notifyPlugins("beforeDatasetsDraw", {
      cancelable: true
    }) === false) {
      return;
    }
    const metasets = this.getSortedVisibleDatasetMetas();
    for (let i2 = metasets.length - 1; i2 >= 0; --i2) {
      this._drawDataset(metasets[i2]);
    }
    this.notifyPlugins("afterDatasetsDraw");
  }
  _drawDataset(meta) {
    const ctx = this.ctx;
    const args = {
      meta,
      index: meta.index,
      cancelable: true
    };
    const clip = getDatasetClipArea(this, meta);
    if (this.notifyPlugins("beforeDatasetDraw", args) === false) {
      return;
    }
    if (clip) {
      clipArea(ctx, clip);
    }
    meta.controller.draw();
    if (clip) {
      unclipArea(ctx);
    }
    args.cancelable = false;
    this.notifyPlugins("afterDatasetDraw", args);
  }
  isPointInArea(point) {
    return _isPointInArea(point, this.chartArea, this._minPadding);
  }
  getElementsAtEventForMode(e2, mode, options, useFinalPosition) {
    const method = Interaction.modes[mode];
    if (typeof method === "function") {
      return method(this, e2, options, useFinalPosition);
    }
    return [];
  }
  getDatasetMeta(datasetIndex) {
    const dataset = this.data.datasets[datasetIndex];
    const metasets = this._metasets;
    let meta = metasets.filter((x2) => x2 && x2._dataset === dataset).pop();
    if (!meta) {
      meta = {
        type: null,
        data: [],
        dataset: null,
        controller: null,
        hidden: null,
        xAxisID: null,
        yAxisID: null,
        order: dataset && dataset.order || 0,
        index: datasetIndex,
        _dataset: dataset,
        _parsed: [],
        _sorted: false
      };
      metasets.push(meta);
    }
    return meta;
  }
  getContext() {
    return this.$context || (this.$context = createContext(null, {
      chart: this,
      type: "chart"
    }));
  }
  getVisibleDatasetCount() {
    return this.getSortedVisibleDatasetMetas().length;
  }
  isDatasetVisible(datasetIndex) {
    const dataset = this.data.datasets[datasetIndex];
    if (!dataset) {
      return false;
    }
    const meta = this.getDatasetMeta(datasetIndex);
    return typeof meta.hidden === "boolean" ? !meta.hidden : !dataset.hidden;
  }
  setDatasetVisibility(datasetIndex, visible) {
    const meta = this.getDatasetMeta(datasetIndex);
    meta.hidden = !visible;
  }
  toggleDataVisibility(index) {
    this._hiddenIndices[index] = !this._hiddenIndices[index];
  }
  getDataVisibility(index) {
    return !this._hiddenIndices[index];
  }
  _updateVisibility(datasetIndex, dataIndex, visible) {
    const mode = visible ? "show" : "hide";
    const meta = this.getDatasetMeta(datasetIndex);
    const anims = meta.controller._resolveAnimations(void 0, mode);
    if (defined(dataIndex)) {
      meta.data[dataIndex].hidden = !visible;
      this.update();
    } else {
      this.setDatasetVisibility(datasetIndex, visible);
      anims.update(meta, {
        visible
      });
      this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : void 0);
    }
  }
  hide(datasetIndex, dataIndex) {
    this._updateVisibility(datasetIndex, dataIndex, false);
  }
  show(datasetIndex, dataIndex) {
    this._updateVisibility(datasetIndex, dataIndex, true);
  }
  _destroyDatasetMeta(datasetIndex) {
    const meta = this._metasets[datasetIndex];
    if (meta && meta.controller) {
      meta.controller._destroy();
    }
    delete this._metasets[datasetIndex];
  }
  _stop() {
    let i2, ilen;
    this.stop();
    animator.remove(this);
    for (i2 = 0, ilen = this.data.datasets.length; i2 < ilen; ++i2) {
      this._destroyDatasetMeta(i2);
    }
  }
  destroy() {
    this.notifyPlugins("beforeDestroy");
    const { canvas, ctx } = this;
    this._stop();
    this.config.clearCache();
    if (canvas) {
      this.unbindEvents();
      clearCanvas(canvas, ctx);
      this.platform.releaseContext(ctx);
      this.canvas = null;
      this.ctx = null;
    }
    delete instances[this.id];
    this.notifyPlugins("afterDestroy");
  }
  toBase64Image(...args) {
    return this.canvas.toDataURL(...args);
  }
  bindEvents() {
    this.bindUserEvents();
    if (this.options.responsive) {
      this.bindResponsiveEvents();
    } else {
      this.attached = true;
    }
  }
  bindUserEvents() {
    const listeners = this._listeners;
    const platform = this.platform;
    const _add = (type, listener2) => {
      platform.addEventListener(this, type, listener2);
      listeners[type] = listener2;
    };
    const listener = (e2, x2, y2) => {
      e2.offsetX = x2;
      e2.offsetY = y2;
      this._eventHandler(e2);
    };
    each(this.options.events, (type) => _add(type, listener));
  }
  bindResponsiveEvents() {
    if (!this._responsiveListeners) {
      this._responsiveListeners = {};
    }
    const listeners = this._responsiveListeners;
    const platform = this.platform;
    const _add = (type, listener2) => {
      platform.addEventListener(this, type, listener2);
      listeners[type] = listener2;
    };
    const _remove = (type, listener2) => {
      if (listeners[type]) {
        platform.removeEventListener(this, type, listener2);
        delete listeners[type];
      }
    };
    const listener = (width, height) => {
      if (this.canvas) {
        this.resize(width, height);
      }
    };
    let detached;
    const attached = () => {
      _remove("attach", attached);
      this.attached = true;
      this.resize();
      _add("resize", listener);
      _add("detach", detached);
    };
    detached = () => {
      this.attached = false;
      _remove("resize", listener);
      this._stop();
      this._resize(0, 0);
      _add("attach", attached);
    };
    if (platform.isAttached(this.canvas)) {
      attached();
    } else {
      detached();
    }
  }
  unbindEvents() {
    each(this._listeners, (listener, type) => {
      this.platform.removeEventListener(this, type, listener);
    });
    this._listeners = {};
    each(this._responsiveListeners, (listener, type) => {
      this.platform.removeEventListener(this, type, listener);
    });
    this._responsiveListeners = void 0;
  }
  updateHoverStyle(items, mode, enabled) {
    const prefix = enabled ? "set" : "remove";
    let meta, item, i2, ilen;
    if (mode === "dataset") {
      meta = this.getDatasetMeta(items[0].datasetIndex);
      meta.controller["_" + prefix + "DatasetHoverStyle"]();
    }
    for (i2 = 0, ilen = items.length; i2 < ilen; ++i2) {
      item = items[i2];
      const controller = item && this.getDatasetMeta(item.datasetIndex).controller;
      if (controller) {
        controller[prefix + "HoverStyle"](item.element, item.datasetIndex, item.index);
      }
    }
  }
  getActiveElements() {
    return this._active || [];
  }
  setActiveElements(activeElements) {
    const lastActive = this._active || [];
    const active = activeElements.map(({ datasetIndex, index }) => {
      const meta = this.getDatasetMeta(datasetIndex);
      if (!meta) {
        throw new Error("No dataset found at index " + datasetIndex);
      }
      return {
        datasetIndex,
        element: meta.data[index],
        index
      };
    });
    const changed = !_elementsEqual(active, lastActive);
    if (changed) {
      this._active = active;
      this._lastEvent = null;
      this._updateHoverStyles(active, lastActive);
    }
  }
  notifyPlugins(hook, args, filter2) {
    return this._plugins.notify(this, hook, args, filter2);
  }
  isPluginEnabled(pluginId) {
    return this._plugins._cache.filter((p2) => p2.plugin.id === pluginId).length === 1;
  }
  _updateHoverStyles(active, lastActive, replay) {
    const hoverOptions = this.options.hover;
    const diff = (a2, b2) => a2.filter((x2) => !b2.some((y2) => x2.datasetIndex === y2.datasetIndex && x2.index === y2.index));
    const deactivated = diff(lastActive, active);
    const activated = replay ? active : diff(active, lastActive);
    if (deactivated.length) {
      this.updateHoverStyle(deactivated, hoverOptions.mode, false);
    }
    if (activated.length && hoverOptions.mode) {
      this.updateHoverStyle(activated, hoverOptions.mode, true);
    }
  }
  _eventHandler(e2, replay) {
    const args = {
      event: e2,
      replay,
      cancelable: true,
      inChartArea: this.isPointInArea(e2)
    };
    const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e2.native.type);
    if (this.notifyPlugins("beforeEvent", args, eventFilter) === false) {
      return;
    }
    const changed = this._handleEvent(e2, replay, args.inChartArea);
    args.cancelable = false;
    this.notifyPlugins("afterEvent", args, eventFilter);
    if (changed || args.changed) {
      this.render();
    }
    return this;
  }
  _handleEvent(e2, replay, inChartArea) {
    const { _active: lastActive = [], options } = this;
    const useFinalPosition = replay;
    const active = this._getActiveElements(e2, lastActive, inChartArea, useFinalPosition);
    const isClick = _isClickEvent(e2);
    const lastEvent = determineLastEvent(e2, this._lastEvent, inChartArea, isClick);
    if (inChartArea) {
      this._lastEvent = null;
      callback(options.onHover, [
        e2,
        active,
        this
      ], this);
      if (isClick) {
        callback(options.onClick, [
          e2,
          active,
          this
        ], this);
      }
    }
    const changed = !_elementsEqual(active, lastActive);
    if (changed || replay) {
      this._active = active;
      this._updateHoverStyles(active, lastActive, replay);
    }
    this._lastEvent = lastEvent;
    return changed;
  }
  _getActiveElements(e2, lastActive, inChartArea, useFinalPosition) {
    if (e2.type === "mouseout") {
      return [];
    }
    if (!inChartArea) {
      return lastActive;
    }
    const hoverOptions = this.options.hover;
    return this.getElementsAtEventForMode(e2, hoverOptions.mode, hoverOptions, useFinalPosition);
  }
};
__publicField(Chart, "defaults", defaults2);
__publicField(Chart, "instances", instances);
__publicField(Chart, "overrides", overrides);
__publicField(Chart, "registry", registry);
__publicField(Chart, "version", version);
__publicField(Chart, "getChart", getChart);
function invalidatePlugins() {
  return each(Chart.instances, (chart) => chart._plugins.invalidate());
}
function clipSelf(ctx, element, endAngle) {
  const { startAngle, x: x2, y: y2, outerRadius, innerRadius, options } = element;
  const { borderWidth, borderJoinStyle } = options;
  const outerAngleClip = Math.min(borderWidth / outerRadius, _normalizeAngle(startAngle - endAngle));
  ctx.beginPath();
  ctx.arc(x2, y2, outerRadius - borderWidth / 2, startAngle + outerAngleClip / 2, endAngle - outerAngleClip / 2);
  if (innerRadius > 0) {
    const innerAngleClip = Math.min(borderWidth / innerRadius, _normalizeAngle(startAngle - endAngle));
    ctx.arc(x2, y2, innerRadius + borderWidth / 2, endAngle - innerAngleClip / 2, startAngle + innerAngleClip / 2, true);
  } else {
    const clipWidth = Math.min(borderWidth / 2, outerRadius * _normalizeAngle(startAngle - endAngle));
    if (borderJoinStyle === "round") {
      ctx.arc(x2, y2, clipWidth, endAngle - PI / 2, startAngle + PI / 2, true);
    } else if (borderJoinStyle === "bevel") {
      const r2 = 2 * clipWidth * clipWidth;
      const endX = -r2 * Math.cos(endAngle + PI / 2) + x2;
      const endY = -r2 * Math.sin(endAngle + PI / 2) + y2;
      const startX = r2 * Math.cos(startAngle + PI / 2) + x2;
      const startY = r2 * Math.sin(startAngle + PI / 2) + y2;
      ctx.lineTo(endX, endY);
      ctx.lineTo(startX, startY);
    }
  }
  ctx.closePath();
  ctx.moveTo(0, 0);
  ctx.rect(0, 0, ctx.canvas.width, ctx.canvas.height);
  ctx.clip("evenodd");
}
function clipArc(ctx, element, endAngle) {
  const { startAngle, pixelMargin, x: x2, y: y2, outerRadius, innerRadius } = element;
  let angleMargin = pixelMargin / outerRadius;
  ctx.beginPath();
  ctx.arc(x2, y2, outerRadius, startAngle - angleMargin, endAngle + angleMargin);
  if (innerRadius > pixelMargin) {
    angleMargin = pixelMargin / innerRadius;
    ctx.arc(x2, y2, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);
  } else {
    ctx.arc(x2, y2, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);
  }
  ctx.closePath();
  ctx.clip();
}
function toRadiusCorners(value) {
  return _readValueToProps(value, [
    "outerStart",
    "outerEnd",
    "innerStart",
    "innerEnd"
  ]);
}
function parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) {
  const o2 = toRadiusCorners(arc.options.borderRadius);
  const halfThickness = (outerRadius - innerRadius) / 2;
  const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);
  const computeOuterLimit = (val) => {
    const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;
    return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));
  };
  return {
    outerStart: computeOuterLimit(o2.outerStart),
    outerEnd: computeOuterLimit(o2.outerEnd),
    innerStart: _limitValue(o2.innerStart, 0, innerLimit),
    innerEnd: _limitValue(o2.innerEnd, 0, innerLimit)
  };
}
function rThetaToXY(r2, theta, x2, y2) {
  return {
    x: x2 + r2 * Math.cos(theta),
    y: y2 + r2 * Math.sin(theta)
  };
}
function pathArc(ctx, element, offset, spacing, end, circular) {
  const { x: x2, y: y2, startAngle: start, pixelMargin, innerRadius: innerR } = element;
  const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);
  const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;
  let spacingOffset = 0;
  const alpha2 = end - start;
  if (spacing) {
    const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;
    const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;
    const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;
    const adjustedAngle = avNogSpacingRadius !== 0 ? alpha2 * avNogSpacingRadius / (avNogSpacingRadius + spacing) : alpha2;
    spacingOffset = (alpha2 - adjustedAngle) / 2;
  }
  const beta = Math.max(1e-3, alpha2 * outerRadius - offset / PI) / outerRadius;
  const angleOffset = (alpha2 - beta) / 2;
  const startAngle = start + angleOffset + spacingOffset;
  const endAngle = end - angleOffset - spacingOffset;
  const { outerStart, outerEnd, innerStart, innerEnd } = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle);
  const outerStartAdjustedRadius = outerRadius - outerStart;
  const outerEndAdjustedRadius = outerRadius - outerEnd;
  const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;
  const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;
  const innerStartAdjustedRadius = innerRadius + innerStart;
  const innerEndAdjustedRadius = innerRadius + innerEnd;
  const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;
  const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;
  ctx.beginPath();
  if (circular) {
    const outerMidAdjustedAngle = (outerStartAdjustedAngle + outerEndAdjustedAngle) / 2;
    ctx.arc(x2, y2, outerRadius, outerStartAdjustedAngle, outerMidAdjustedAngle);
    ctx.arc(x2, y2, outerRadius, outerMidAdjustedAngle, outerEndAdjustedAngle);
    if (outerEnd > 0) {
      const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x2, y2);
      ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);
    }
    const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x2, y2);
    ctx.lineTo(p4.x, p4.y);
    if (innerEnd > 0) {
      const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x2, y2);
      ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);
    }
    const innerMidAdjustedAngle = (endAngle - innerEnd / innerRadius + (startAngle + innerStart / innerRadius)) / 2;
    ctx.arc(x2, y2, innerRadius, endAngle - innerEnd / innerRadius, innerMidAdjustedAngle, true);
    ctx.arc(x2, y2, innerRadius, innerMidAdjustedAngle, startAngle + innerStart / innerRadius, true);
    if (innerStart > 0) {
      const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x2, y2);
      ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);
    }
    const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x2, y2);
    ctx.lineTo(p8.x, p8.y);
    if (outerStart > 0) {
      const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x2, y2);
      ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);
    }
  } else {
    ctx.moveTo(x2, y2);
    const outerStartX = Math.cos(outerStartAdjustedAngle) * outerRadius + x2;
    const outerStartY = Math.sin(outerStartAdjustedAngle) * outerRadius + y2;
    ctx.lineTo(outerStartX, outerStartY);
    const outerEndX = Math.cos(outerEndAdjustedAngle) * outerRadius + x2;
    const outerEndY = Math.sin(outerEndAdjustedAngle) * outerRadius + y2;
    ctx.lineTo(outerEndX, outerEndY);
  }
  ctx.closePath();
}
function drawArc(ctx, element, offset, spacing, circular) {
  const { fullCircles, startAngle, circumference } = element;
  let endAngle = element.endAngle;
  if (fullCircles) {
    pathArc(ctx, element, offset, spacing, endAngle, circular);
    for (let i2 = 0; i2 < fullCircles; ++i2) {
      ctx.fill();
    }
    if (!isNaN(circumference)) {
      endAngle = startAngle + (circumference % TAU || TAU);
    }
  }
  pathArc(ctx, element, offset, spacing, endAngle, circular);
  ctx.fill();
  return endAngle;
}
function drawBorder(ctx, element, offset, spacing, circular) {
  const { fullCircles, startAngle, circumference, options } = element;
  const { borderWidth, borderJoinStyle, borderDash, borderDashOffset, borderRadius } = options;
  const inner = options.borderAlign === "inner";
  if (!borderWidth) {
    return;
  }
  ctx.setLineDash(borderDash || []);
  ctx.lineDashOffset = borderDashOffset;
  if (inner) {
    ctx.lineWidth = borderWidth * 2;
    ctx.lineJoin = borderJoinStyle || "round";
  } else {
    ctx.lineWidth = borderWidth;
    ctx.lineJoin = borderJoinStyle || "bevel";
  }
  let endAngle = element.endAngle;
  if (fullCircles) {
    pathArc(ctx, element, offset, spacing, endAngle, circular);
    for (let i2 = 0; i2 < fullCircles; ++i2) {
      ctx.stroke();
    }
    if (!isNaN(circumference)) {
      endAngle = startAngle + (circumference % TAU || TAU);
    }
  }
  if (inner) {
    clipArc(ctx, element, endAngle);
  }
  if (options.selfJoin && endAngle - startAngle >= PI && borderRadius === 0 && borderJoinStyle !== "miter") {
    clipSelf(ctx, element, endAngle);
  }
  if (!fullCircles) {
    pathArc(ctx, element, offset, spacing, endAngle, circular);
    ctx.stroke();
  }
}
var ArcElement = class extends Element {
  constructor(cfg) {
    super();
    __publicField(this, "circumference");
    __publicField(this, "endAngle");
    __publicField(this, "fullCircles");
    __publicField(this, "innerRadius");
    __publicField(this, "outerRadius");
    __publicField(this, "pixelMargin");
    __publicField(this, "startAngle");
    this.options = void 0;
    this.circumference = void 0;
    this.startAngle = void 0;
    this.endAngle = void 0;
    this.innerRadius = void 0;
    this.outerRadius = void 0;
    this.pixelMargin = 0;
    this.fullCircles = 0;
    if (cfg) {
      Object.assign(this, cfg);
    }
  }
  inRange(chartX, chartY, useFinalPosition) {
    const point = this.getProps([
      "x",
      "y"
    ], useFinalPosition);
    const { angle, distance } = getAngleFromPoint(point, {
      x: chartX,
      y: chartY
    });
    const { startAngle, endAngle, innerRadius, outerRadius, circumference } = this.getProps([
      "startAngle",
      "endAngle",
      "innerRadius",
      "outerRadius",
      "circumference"
    ], useFinalPosition);
    const rAdjust = (this.options.spacing + this.options.borderWidth) / 2;
    const _circumference = valueOrDefault(circumference, endAngle - startAngle);
    const nonZeroBetween = _angleBetween(angle, startAngle, endAngle) && startAngle !== endAngle;
    const betweenAngles = _circumference >= TAU || nonZeroBetween;
    const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);
    return betweenAngles && withinRadius;
  }
  getCenterPoint(useFinalPosition) {
    const { x: x2, y: y2, startAngle, endAngle, innerRadius, outerRadius } = this.getProps([
      "x",
      "y",
      "startAngle",
      "endAngle",
      "innerRadius",
      "outerRadius"
    ], useFinalPosition);
    const { offset, spacing } = this.options;
    const halfAngle = (startAngle + endAngle) / 2;
    const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;
    return {
      x: x2 + Math.cos(halfAngle) * halfRadius,
      y: y2 + Math.sin(halfAngle) * halfRadius
    };
  }
  tooltipPosition(useFinalPosition) {
    return this.getCenterPoint(useFinalPosition);
  }
  draw(ctx) {
    const { options, circumference } = this;
    const offset = (options.offset || 0) / 4;
    const spacing = (options.spacing || 0) / 2;
    const circular = options.circular;
    this.pixelMargin = options.borderAlign === "inner" ? 0.33 : 0;
    this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;
    if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {
      return;
    }
    ctx.save();
    const halfAngle = (this.startAngle + this.endAngle) / 2;
    ctx.translate(Math.cos(halfAngle) * offset, Math.sin(halfAngle) * offset);
    const fix = 1 - Math.sin(Math.min(PI, circumference || 0));
    const radiusOffset = offset * fix;
    ctx.fillStyle = options.backgroundColor;
    ctx.strokeStyle = options.borderColor;
    drawArc(ctx, this, radiusOffset, spacing, circular);
    drawBorder(ctx, this, radiusOffset, spacing, circular);
    ctx.restore();
  }
};
__publicField(ArcElement, "id", "arc");
__publicField(ArcElement, "defaults", {
  borderAlign: "center",
  borderColor: "#fff",
  borderDash: [],
  borderDashOffset: 0,
  borderJoinStyle: void 0,
  borderRadius: 0,
  borderWidth: 2,
  offset: 0,
  spacing: 0,
  angle: void 0,
  circular: true,
  selfJoin: false
});
__publicField(ArcElement, "defaultRoutes", {
  backgroundColor: "backgroundColor"
});
__publicField(ArcElement, "descriptors", {
  _scriptable: true,
  _indexable: (name) => name !== "borderDash"
});
function getBarBounds(bar, useFinalPosition) {
  const { x: x2, y: y2, base, width, height } = bar.getProps([
    "x",
    "y",
    "base",
    "width",
    "height"
  ], useFinalPosition);
  let left, right, top, bottom, half;
  if (bar.horizontal) {
    half = height / 2;
    left = Math.min(x2, base);
    right = Math.max(x2, base);
    top = y2 - half;
    bottom = y2 + half;
  } else {
    half = width / 2;
    left = x2 - half;
    right = x2 + half;
    top = Math.min(y2, base);
    bottom = Math.max(y2, base);
  }
  return {
    left,
    top,
    right,
    bottom
  };
}
function skipOrLimit(skip2, value, min, max) {
  return skip2 ? 0 : _limitValue(value, min, max);
}
function parseBorderWidth(bar, maxW, maxH) {
  const value = bar.options.borderWidth;
  const skip2 = bar.borderSkipped;
  const o2 = toTRBL(value);
  return {
    t: skipOrLimit(skip2.top, o2.top, 0, maxH),
    r: skipOrLimit(skip2.right, o2.right, 0, maxW),
    b: skipOrLimit(skip2.bottom, o2.bottom, 0, maxH),
    l: skipOrLimit(skip2.left, o2.left, 0, maxW)
  };
}
function parseBorderRadius(bar, maxW, maxH) {
  const { enableBorderRadius } = bar.getProps([
    "enableBorderRadius"
  ]);
  const value = bar.options.borderRadius;
  const o2 = toTRBLCorners(value);
  const maxR = Math.min(maxW, maxH);
  const skip2 = bar.borderSkipped;
  const enableBorder = enableBorderRadius || isObject(value);
  return {
    topLeft: skipOrLimit(!enableBorder || skip2.top || skip2.left, o2.topLeft, 0, maxR),
    topRight: skipOrLimit(!enableBorder || skip2.top || skip2.right, o2.topRight, 0, maxR),
    bottomLeft: skipOrLimit(!enableBorder || skip2.bottom || skip2.left, o2.bottomLeft, 0, maxR),
    bottomRight: skipOrLimit(!enableBorder || skip2.bottom || skip2.right, o2.bottomRight, 0, maxR)
  };
}
function boundingRects(bar) {
  const bounds = getBarBounds(bar);
  const width = bounds.right - bounds.left;
  const height = bounds.bottom - bounds.top;
  const border = parseBorderWidth(bar, width / 2, height / 2);
  const radius = parseBorderRadius(bar, width / 2, height / 2);
  return {
    outer: {
      x: bounds.left,
      y: bounds.top,
      w: width,
      h: height,
      radius
    },
    inner: {
      x: bounds.left + border.l,
      y: bounds.top + border.t,
      w: width - border.l - border.r,
      h: height - border.t - border.b,
      radius: {
        topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),
        topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),
        bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),
        bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r))
      }
    }
  };
}
function inRange(bar, x2, y2, useFinalPosition) {
  const skipX = x2 === null;
  const skipY = y2 === null;
  const skipBoth = skipX && skipY;
  const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);
  return bounds && (skipX || _isBetween(x2, bounds.left, bounds.right)) && (skipY || _isBetween(y2, bounds.top, bounds.bottom));
}
function hasRadius(radius) {
  return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;
}
function addNormalRectPath(ctx, rect) {
  ctx.rect(rect.x, rect.y, rect.w, rect.h);
}
function inflateRect(rect, amount, refRect = {}) {
  const x2 = rect.x !== refRect.x ? -amount : 0;
  const y2 = rect.y !== refRect.y ? -amount : 0;
  const w2 = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x2;
  const h3 = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y2;
  return {
    x: rect.x + x2,
    y: rect.y + y2,
    w: rect.w + w2,
    h: rect.h + h3,
    radius: rect.radius
  };
}
var BarElement = class extends Element {
  constructor(cfg) {
    super();
    this.options = void 0;
    this.horizontal = void 0;
    this.base = void 0;
    this.width = void 0;
    this.height = void 0;
    this.inflateAmount = void 0;
    if (cfg) {
      Object.assign(this, cfg);
    }
  }
  draw(ctx) {
    const { inflateAmount, options: { borderColor, backgroundColor } } = this;
    const { inner, outer } = boundingRects(this);
    const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;
    ctx.save();
    if (outer.w !== inner.w || outer.h !== inner.h) {
      ctx.beginPath();
      addRectPath(ctx, inflateRect(outer, inflateAmount, inner));
      ctx.clip();
      addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));
      ctx.fillStyle = borderColor;
      ctx.fill("evenodd");
    }
    ctx.beginPath();
    addRectPath(ctx, inflateRect(inner, inflateAmount));
    ctx.fillStyle = backgroundColor;
    ctx.fill();
    ctx.restore();
  }
  inRange(mouseX, mouseY, useFinalPosition) {
    return inRange(this, mouseX, mouseY, useFinalPosition);
  }
  inXRange(mouseX, useFinalPosition) {
    return inRange(this, mouseX, null, useFinalPosition);
  }
  inYRange(mouseY, useFinalPosition) {
    return inRange(this, null, mouseY, useFinalPosition);
  }
  getCenterPoint(useFinalPosition) {
    const { x: x2, y: y2, base, horizontal } = this.getProps([
      "x",
      "y",
      "base",
      "horizontal"
    ], useFinalPosition);
    return {
      x: horizontal ? (x2 + base) / 2 : x2,
      y: horizontal ? y2 : (y2 + base) / 2
    };
  }
  getRange(axis) {
    return axis === "x" ? this.width / 2 : this.height / 2;
  }
};
__publicField(BarElement, "id", "bar");
__publicField(BarElement, "defaults", {
  borderSkipped: "start",
  borderWidth: 0,
  borderRadius: 0,
  inflateAmount: "auto",
  pointStyle: void 0
});
__publicField(BarElement, "defaultRoutes", {
  backgroundColor: "backgroundColor",
  borderColor: "borderColor"
});
var getBoxSize = (labelOpts, fontSize) => {
  let { boxHeight = fontSize, boxWidth = fontSize } = labelOpts;
  if (labelOpts.usePointStyle) {
    boxHeight = Math.min(boxHeight, fontSize);
    boxWidth = labelOpts.pointStyleWidth || Math.min(boxWidth, fontSize);
  }
  return {
    boxWidth,
    boxHeight,
    itemHeight: Math.max(fontSize, boxHeight)
  };
};
var itemsEqual = (a2, b2) => a2 !== null && b2 !== null && a2.datasetIndex === b2.datasetIndex && a2.index === b2.index;
var Legend = class extends Element {
  constructor(config) {
    super();
    this._added = false;
    this.legendHitBoxes = [];
    this._hoveredItem = null;
    this.doughnutMode = false;
    this.chart = config.chart;
    this.options = config.options;
    this.ctx = config.ctx;
    this.legendItems = void 0;
    this.columnSizes = void 0;
    this.lineWidths = void 0;
    this.maxHeight = void 0;
    this.maxWidth = void 0;
    this.top = void 0;
    this.bottom = void 0;
    this.left = void 0;
    this.right = void 0;
    this.height = void 0;
    this.width = void 0;
    this._margins = void 0;
    this.position = void 0;
    this.weight = void 0;
    this.fullSize = void 0;
  }
  update(maxWidth, maxHeight, margins) {
    this.maxWidth = maxWidth;
    this.maxHeight = maxHeight;
    this._margins = margins;
    this.setDimensions();
    this.buildLabels();
    this.fit();
  }
  setDimensions() {
    if (this.isHorizontal()) {
      this.width = this.maxWidth;
      this.left = this._margins.left;
      this.right = this.width;
    } else {
      this.height = this.maxHeight;
      this.top = this._margins.top;
      this.bottom = this.height;
    }
  }
  buildLabels() {
    const labelOpts = this.options.labels || {};
    let legendItems = callback(labelOpts.generateLabels, [
      this.chart
    ], this) || [];
    if (labelOpts.filter) {
      legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));
    }
    if (labelOpts.sort) {
      legendItems = legendItems.sort((a2, b2) => labelOpts.sort(a2, b2, this.chart.data));
    }
    if (this.options.reverse) {
      legendItems.reverse();
    }
    this.legendItems = legendItems;
  }
  fit() {
    const { options, ctx } = this;
    if (!options.display) {
      this.width = this.height = 0;
      return;
    }
    const labelOpts = options.labels;
    const labelFont = toFont(labelOpts.font);
    const fontSize = labelFont.size;
    const titleHeight = this._computeTitleHeight();
    const { boxWidth, itemHeight } = getBoxSize(labelOpts, fontSize);
    let width, height;
    ctx.font = labelFont.string;
    if (this.isHorizontal()) {
      width = this.maxWidth;
      height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;
    } else {
      height = this.maxHeight;
      width = this._fitCols(titleHeight, labelFont, boxWidth, itemHeight) + 10;
    }
    this.width = Math.min(width, options.maxWidth || this.maxWidth);
    this.height = Math.min(height, options.maxHeight || this.maxHeight);
  }
  _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {
    const { ctx, maxWidth, options: { labels: { padding } } } = this;
    const hitboxes = this.legendHitBoxes = [];
    const lineWidths = this.lineWidths = [
      0
    ];
    const lineHeight = itemHeight + padding;
    let totalHeight = titleHeight;
    ctx.textAlign = "left";
    ctx.textBaseline = "middle";
    let row = -1;
    let top = -lineHeight;
    this.legendItems.forEach((legendItem, i2) => {
      const itemWidth = boxWidth + fontSize / 2 + ctx.measureText(legendItem.text).width;
      if (i2 === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {
        totalHeight += lineHeight;
        lineWidths[lineWidths.length - (i2 > 0 ? 0 : 1)] = 0;
        top += lineHeight;
        row++;
      }
      hitboxes[i2] = {
        left: 0,
        top,
        row,
        width: itemWidth,
        height: itemHeight
      };
      lineWidths[lineWidths.length - 1] += itemWidth + padding;
    });
    return totalHeight;
  }
  _fitCols(titleHeight, labelFont, boxWidth, _itemHeight) {
    const { ctx, maxHeight, options: { labels: { padding } } } = this;
    const hitboxes = this.legendHitBoxes = [];
    const columnSizes = this.columnSizes = [];
    const heightLimit = maxHeight - titleHeight;
    let totalWidth = padding;
    let currentColWidth = 0;
    let currentColHeight = 0;
    let left = 0;
    let col = 0;
    this.legendItems.forEach((legendItem, i2) => {
      const { itemWidth, itemHeight } = calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight);
      if (i2 > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {
        totalWidth += currentColWidth + padding;
        columnSizes.push({
          width: currentColWidth,
          height: currentColHeight
        });
        left += currentColWidth + padding;
        col++;
        currentColWidth = currentColHeight = 0;
      }
      hitboxes[i2] = {
        left,
        top: currentColHeight,
        col,
        width: itemWidth,
        height: itemHeight
      };
      currentColWidth = Math.max(currentColWidth, itemWidth);
      currentColHeight += itemHeight + padding;
    });
    totalWidth += currentColWidth;
    columnSizes.push({
      width: currentColWidth,
      height: currentColHeight
    });
    return totalWidth;
  }
  adjustHitBoxes() {
    if (!this.options.display) {
      return;
    }
    const titleHeight = this._computeTitleHeight();
    const { legendHitBoxes: hitboxes, options: { align, labels: { padding }, rtl } } = this;
    const rtlHelper = getRtlAdapter(rtl, this.left, this.width);
    if (this.isHorizontal()) {
      let row = 0;
      let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
      for (const hitbox of hitboxes) {
        if (row !== hitbox.row) {
          row = hitbox.row;
          left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
        }
        hitbox.top += this.top + titleHeight + padding;
        hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);
        left += hitbox.width + padding;
      }
    } else {
      let col = 0;
      let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
      for (const hitbox of hitboxes) {
        if (hitbox.col !== col) {
          col = hitbox.col;
          top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
        }
        hitbox.top = top;
        hitbox.left += this.left + padding;
        hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);
        top += hitbox.height + padding;
      }
    }
  }
  isHorizontal() {
    return this.options.position === "top" || this.options.position === "bottom";
  }
  draw() {
    if (this.options.display) {
      const ctx = this.ctx;
      clipArea(ctx, this);
      this._draw();
      unclipArea(ctx);
    }
  }
  _draw() {
    const { options: opts, columnSizes, lineWidths, ctx } = this;
    const { align, labels: labelOpts } = opts;
    const defaultColor = defaults2.color;
    const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
    const labelFont = toFont(labelOpts.font);
    const { padding } = labelOpts;
    const fontSize = labelFont.size;
    const halfFontSize = fontSize / 2;
    let cursor;
    this.drawTitle();
    ctx.textAlign = rtlHelper.textAlign("left");
    ctx.textBaseline = "middle";
    ctx.lineWidth = 0.5;
    ctx.font = labelFont.string;
    const { boxWidth, boxHeight, itemHeight } = getBoxSize(labelOpts, fontSize);
    const drawLegendBox = function(x2, y2, legendItem) {
      if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {
        return;
      }
      ctx.save();
      const lineWidth = valueOrDefault(legendItem.lineWidth, 1);
      ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);
      ctx.lineCap = valueOrDefault(legendItem.lineCap, "butt");
      ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);
      ctx.lineJoin = valueOrDefault(legendItem.lineJoin, "miter");
      ctx.lineWidth = lineWidth;
      ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);
      ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));
      if (labelOpts.usePointStyle) {
        const drawOptions = {
          radius: boxHeight * Math.SQRT2 / 2,
          pointStyle: legendItem.pointStyle,
          rotation: legendItem.rotation,
          borderWidth: lineWidth
        };
        const centerX = rtlHelper.xPlus(x2, boxWidth / 2);
        const centerY = y2 + halfFontSize;
        drawPointLegend(ctx, drawOptions, centerX, centerY, labelOpts.pointStyleWidth && boxWidth);
      } else {
        const yBoxTop = y2 + Math.max((fontSize - boxHeight) / 2, 0);
        const xBoxLeft = rtlHelper.leftForLtr(x2, boxWidth);
        const borderRadius = toTRBLCorners(legendItem.borderRadius);
        ctx.beginPath();
        if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
          addRoundedRectPath(ctx, {
            x: xBoxLeft,
            y: yBoxTop,
            w: boxWidth,
            h: boxHeight,
            radius: borderRadius
          });
        } else {
          ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);
        }
        ctx.fill();
        if (lineWidth !== 0) {
          ctx.stroke();
        }
      }
      ctx.restore();
    };
    const fillText = function(x2, y2, legendItem) {
      renderText(ctx, legendItem.text, x2, y2 + itemHeight / 2, labelFont, {
        strikethrough: legendItem.hidden,
        textAlign: rtlHelper.textAlign(legendItem.textAlign)
      });
    };
    const isHorizontal = this.isHorizontal();
    const titleHeight = this._computeTitleHeight();
    if (isHorizontal) {
      cursor = {
        x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),
        y: this.top + padding + titleHeight,
        line: 0
      };
    } else {
      cursor = {
        x: this.left + padding,
        y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),
        line: 0
      };
    }
    overrideTextDirection(this.ctx, opts.textDirection);
    const lineHeight = itemHeight + padding;
    this.legendItems.forEach((legendItem, i2) => {
      ctx.strokeStyle = legendItem.fontColor;
      ctx.fillStyle = legendItem.fontColor;
      const textWidth = ctx.measureText(legendItem.text).width;
      const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));
      const width = boxWidth + halfFontSize + textWidth;
      let x2 = cursor.x;
      let y2 = cursor.y;
      rtlHelper.setWidth(this.width);
      if (isHorizontal) {
        if (i2 > 0 && x2 + width + padding > this.right) {
          y2 = cursor.y += lineHeight;
          cursor.line++;
          x2 = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);
        }
      } else if (i2 > 0 && y2 + lineHeight > this.bottom) {
        x2 = cursor.x = x2 + columnSizes[cursor.line].width + padding;
        cursor.line++;
        y2 = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);
      }
      const realX = rtlHelper.x(x2);
      drawLegendBox(realX, y2, legendItem);
      x2 = _textX(textAlign, x2 + boxWidth + halfFontSize, isHorizontal ? x2 + width : this.right, opts.rtl);
      fillText(rtlHelper.x(x2), y2, legendItem);
      if (isHorizontal) {
        cursor.x += width + padding;
      } else if (typeof legendItem.text !== "string") {
        const fontLineHeight = labelFont.lineHeight;
        cursor.y += calculateLegendItemHeight(legendItem, fontLineHeight) + padding;
      } else {
        cursor.y += lineHeight;
      }
    });
    restoreTextDirection(this.ctx, opts.textDirection);
  }
  drawTitle() {
    const opts = this.options;
    const titleOpts = opts.title;
    const titleFont = toFont(titleOpts.font);
    const titlePadding = toPadding(titleOpts.padding);
    if (!titleOpts.display) {
      return;
    }
    const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
    const ctx = this.ctx;
    const position = titleOpts.position;
    const halfFontSize = titleFont.size / 2;
    const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;
    let y2;
    let left = this.left;
    let maxWidth = this.width;
    if (this.isHorizontal()) {
      maxWidth = Math.max(...this.lineWidths);
      y2 = this.top + topPaddingPlusHalfFontSize;
      left = _alignStartEnd(opts.align, left, this.right - maxWidth);
    } else {
      const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);
      y2 = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());
    }
    const x2 = _alignStartEnd(position, left, left + maxWidth);
    ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));
    ctx.textBaseline = "middle";
    ctx.strokeStyle = titleOpts.color;
    ctx.fillStyle = titleOpts.color;
    ctx.font = titleFont.string;
    renderText(ctx, titleOpts.text, x2, y2, titleFont);
  }
  _computeTitleHeight() {
    const titleOpts = this.options.title;
    const titleFont = toFont(titleOpts.font);
    const titlePadding = toPadding(titleOpts.padding);
    return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;
  }
  _getLegendItemAt(x2, y2) {
    let i2, hitBox, lh;
    if (_isBetween(x2, this.left, this.right) && _isBetween(y2, this.top, this.bottom)) {
      lh = this.legendHitBoxes;
      for (i2 = 0; i2 < lh.length; ++i2) {
        hitBox = lh[i2];
        if (_isBetween(x2, hitBox.left, hitBox.left + hitBox.width) && _isBetween(y2, hitBox.top, hitBox.top + hitBox.height)) {
          return this.legendItems[i2];
        }
      }
    }
    return null;
  }
  handleEvent(e2) {
    const opts = this.options;
    if (!isListened(e2.type, opts)) {
      return;
    }
    const hoveredItem = this._getLegendItemAt(e2.x, e2.y);
    if (e2.type === "mousemove" || e2.type === "mouseout") {
      const previous = this._hoveredItem;
      const sameItem = itemsEqual(previous, hoveredItem);
      if (previous && !sameItem) {
        callback(opts.onLeave, [
          e2,
          previous,
          this
        ], this);
      }
      this._hoveredItem = hoveredItem;
      if (hoveredItem && !sameItem) {
        callback(opts.onHover, [
          e2,
          hoveredItem,
          this
        ], this);
      }
    } else if (hoveredItem) {
      callback(opts.onClick, [
        e2,
        hoveredItem,
        this
      ], this);
    }
  }
};
function calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight) {
  const itemWidth = calculateItemWidth(legendItem, boxWidth, labelFont, ctx);
  const itemHeight = calculateItemHeight(_itemHeight, legendItem, labelFont.lineHeight);
  return {
    itemWidth,
    itemHeight
  };
}
function calculateItemWidth(legendItem, boxWidth, labelFont, ctx) {
  let legendItemText = legendItem.text;
  if (legendItemText && typeof legendItemText !== "string") {
    legendItemText = legendItemText.reduce((a2, b2) => a2.length > b2.length ? a2 : b2);
  }
  return boxWidth + labelFont.size / 2 + ctx.measureText(legendItemText).width;
}
function calculateItemHeight(_itemHeight, legendItem, fontLineHeight) {
  let itemHeight = _itemHeight;
  if (typeof legendItem.text !== "string") {
    itemHeight = calculateLegendItemHeight(legendItem, fontLineHeight);
  }
  return itemHeight;
}
function calculateLegendItemHeight(legendItem, fontLineHeight) {
  const labelHeight = legendItem.text ? legendItem.text.length : 0;
  return fontLineHeight * labelHeight;
}
function isListened(type, opts) {
  if ((type === "mousemove" || type === "mouseout") && (opts.onHover || opts.onLeave)) {
    return true;
  }
  if (opts.onClick && (type === "click" || type === "mouseup")) {
    return true;
  }
  return false;
}
var plugin_legend = {
  id: "legend",
  _element: Legend,
  start(chart, _args, options) {
    const legend = chart.legend = new Legend({
      ctx: chart.ctx,
      options,
      chart
    });
    layouts.configure(chart, legend, options);
    layouts.addBox(chart, legend);
  },
  stop(chart) {
    layouts.removeBox(chart, chart.legend);
    delete chart.legend;
  },
  beforeUpdate(chart, _args, options) {
    const legend = chart.legend;
    layouts.configure(chart, legend, options);
    legend.options = options;
  },
  afterUpdate(chart) {
    const legend = chart.legend;
    legend.buildLabels();
    legend.adjustHitBoxes();
  },
  afterEvent(chart, args) {
    if (!args.replay) {
      chart.legend.handleEvent(args.event);
    }
  },
  defaults: {
    display: true,
    position: "top",
    align: "center",
    fullSize: true,
    reverse: false,
    weight: 1e3,
    onClick(e2, legendItem, legend) {
      const index = legendItem.datasetIndex;
      const ci = legend.chart;
      if (ci.isDatasetVisible(index)) {
        ci.hide(index);
        legendItem.hidden = true;
      } else {
        ci.show(index);
        legendItem.hidden = false;
      }
    },
    onHover: null,
    onLeave: null,
    labels: {
      color: (ctx) => ctx.chart.options.color,
      boxWidth: 40,
      padding: 10,
      generateLabels(chart) {
        const datasets = chart.data.datasets;
        const { labels: { usePointStyle, pointStyle, textAlign, color: color2, useBorderRadius, borderRadius } } = chart.legend.options;
        return chart._getSortedDatasetMetas().map((meta) => {
          const style = meta.controller.getStyle(usePointStyle ? 0 : void 0);
          const borderWidth = toPadding(style.borderWidth);
          return {
            text: datasets[meta.index].label,
            fillStyle: style.backgroundColor,
            fontColor: color2,
            hidden: !meta.visible,
            lineCap: style.borderCapStyle,
            lineDash: style.borderDash,
            lineDashOffset: style.borderDashOffset,
            lineJoin: style.borderJoinStyle,
            lineWidth: (borderWidth.width + borderWidth.height) / 4,
            strokeStyle: style.borderColor,
            pointStyle: pointStyle || style.pointStyle,
            rotation: style.rotation,
            textAlign: textAlign || style.textAlign,
            borderRadius: useBorderRadius && (borderRadius || style.borderRadius),
            datasetIndex: meta.index
          };
        }, this);
      }
    },
    title: {
      color: (ctx) => ctx.chart.options.color,
      display: false,
      position: "center",
      text: ""
    }
  },
  descriptors: {
    _scriptable: (name) => !name.startsWith("on"),
    labels: {
      _scriptable: (name) => ![
        "generateLabels",
        "filter",
        "sort"
      ].includes(name)
    }
  }
};
var Title = class extends Element {
  constructor(config) {
    super();
    this.chart = config.chart;
    this.options = config.options;
    this.ctx = config.ctx;
    this._padding = void 0;
    this.top = void 0;
    this.bottom = void 0;
    this.left = void 0;
    this.right = void 0;
    this.width = void 0;
    this.height = void 0;
    this.position = void 0;
    this.weight = void 0;
    this.fullSize = void 0;
  }
  update(maxWidth, maxHeight) {
    const opts = this.options;
    this.left = 0;
    this.top = 0;
    if (!opts.display) {
      this.width = this.height = this.right = this.bottom = 0;
      return;
    }
    this.width = this.right = maxWidth;
    this.height = this.bottom = maxHeight;
    const lineCount = isArray(opts.text) ? opts.text.length : 1;
    this._padding = toPadding(opts.padding);
    const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;
    if (this.isHorizontal()) {
      this.height = textSize;
    } else {
      this.width = textSize;
    }
  }
  isHorizontal() {
    const pos = this.options.position;
    return pos === "top" || pos === "bottom";
  }
  _drawArgs(offset) {
    const { top, left, bottom, right, options } = this;
    const align = options.align;
    let rotation = 0;
    let maxWidth, titleX, titleY;
    if (this.isHorizontal()) {
      titleX = _alignStartEnd(align, left, right);
      titleY = top + offset;
      maxWidth = right - left;
    } else {
      if (options.position === "left") {
        titleX = left + offset;
        titleY = _alignStartEnd(align, bottom, top);
        rotation = PI * -0.5;
      } else {
        titleX = right - offset;
        titleY = _alignStartEnd(align, top, bottom);
        rotation = PI * 0.5;
      }
      maxWidth = bottom - top;
    }
    return {
      titleX,
      titleY,
      maxWidth,
      rotation
    };
  }
  draw() {
    const ctx = this.ctx;
    const opts = this.options;
    if (!opts.display) {
      return;
    }
    const fontOpts = toFont(opts.font);
    const lineHeight = fontOpts.lineHeight;
    const offset = lineHeight / 2 + this._padding.top;
    const { titleX, titleY, maxWidth, rotation } = this._drawArgs(offset);
    renderText(ctx, opts.text, 0, 0, fontOpts, {
      color: opts.color,
      maxWidth,
      rotation,
      textAlign: _toLeftRightCenter(opts.align),
      textBaseline: "middle",
      translation: [
        titleX,
        titleY
      ]
    });
  }
};
function createTitle(chart, titleOpts) {
  const title = new Title({
    ctx: chart.ctx,
    options: titleOpts,
    chart
  });
  layouts.configure(chart, title, titleOpts);
  layouts.addBox(chart, title);
  chart.titleBlock = title;
}
var plugin_title = {
  id: "title",
  _element: Title,
  start(chart, _args, options) {
    createTitle(chart, options);
  },
  stop(chart) {
    const titleBlock = chart.titleBlock;
    layouts.removeBox(chart, titleBlock);
    delete chart.titleBlock;
  },
  beforeUpdate(chart, _args, options) {
    const title = chart.titleBlock;
    layouts.configure(chart, title, options);
    title.options = options;
  },
  defaults: {
    align: "center",
    display: false,
    font: {
      weight: "bold"
    },
    fullSize: true,
    padding: 10,
    position: "top",
    text: "",
    weight: 2e3
  },
  defaultRoutes: {
    color: "color"
  },
  descriptors: {
    _scriptable: true,
    _indexable: false
  }
};
var map2 = /* @__PURE__ */ new WeakMap();
var plugin_subtitle = {
  id: "subtitle",
  start(chart, _args, options) {
    const title = new Title({
      ctx: chart.ctx,
      options,
      chart
    });
    layouts.configure(chart, title, options);
    layouts.addBox(chart, title);
    map2.set(chart, title);
  },
  stop(chart) {
    layouts.removeBox(chart, map2.get(chart));
    map2.delete(chart);
  },
  beforeUpdate(chart, _args, options) {
    const title = map2.get(chart);
    layouts.configure(chart, title, options);
    title.options = options;
  },
  defaults: {
    align: "center",
    display: false,
    font: {
      weight: "normal"
    },
    fullSize: true,
    padding: 0,
    position: "top",
    text: "",
    weight: 1500
  },
  defaultRoutes: {
    color: "color"
  },
  descriptors: {
    _scriptable: true,
    _indexable: false
  }
};
var positioners = {
  average(items) {
    if (!items.length) {
      return false;
    }
    let i2, len;
    let xSet = /* @__PURE__ */ new Set();
    let y2 = 0;
    let count = 0;
    for (i2 = 0, len = items.length; i2 < len; ++i2) {
      const el = items[i2].element;
      if (el && el.hasValue()) {
        const pos = el.tooltipPosition();
        xSet.add(pos.x);
        y2 += pos.y;
        ++count;
      }
    }
    if (count === 0 || xSet.size === 0) {
      return false;
    }
    const xAverage = [
      ...xSet
    ].reduce((a2, b2) => a2 + b2) / xSet.size;
    return {
      x: xAverage,
      y: y2 / count
    };
  },
  nearest(items, eventPosition) {
    if (!items.length) {
      return false;
    }
    let x2 = eventPosition.x;
    let y2 = eventPosition.y;
    let minDistance = Number.POSITIVE_INFINITY;
    let i2, len, nearestElement;
    for (i2 = 0, len = items.length; i2 < len; ++i2) {
      const el = items[i2].element;
      if (el && el.hasValue()) {
        const center = el.getCenterPoint();
        const d2 = distanceBetweenPoints(eventPosition, center);
        if (d2 < minDistance) {
          minDistance = d2;
          nearestElement = el;
        }
      }
    }
    if (nearestElement) {
      const tp = nearestElement.tooltipPosition();
      x2 = tp.x;
      y2 = tp.y;
    }
    return {
      x: x2,
      y: y2
    };
  }
};
function pushOrConcat(base, toPush) {
  if (toPush) {
    if (isArray(toPush)) {
      Array.prototype.push.apply(base, toPush);
    } else {
      base.push(toPush);
    }
  }
  return base;
}
function splitNewlines(str) {
  if ((typeof str === "string" || str instanceof String) && str.indexOf("\n") > -1) {
    return str.split("\n");
  }
  return str;
}
function createTooltipItem(chart, item) {
  const { element, datasetIndex, index } = item;
  const controller = chart.getDatasetMeta(datasetIndex).controller;
  const { label, value } = controller.getLabelAndValue(index);
  return {
    chart,
    label,
    parsed: controller.getParsed(index),
    raw: chart.data.datasets[datasetIndex].data[index],
    formattedValue: value,
    dataset: controller.getDataset(),
    dataIndex: index,
    datasetIndex,
    element
  };
}
function getTooltipSize(tooltip, options) {
  const ctx = tooltip.chart.ctx;
  const { body, footer, title } = tooltip;
  const { boxWidth, boxHeight } = options;
  const bodyFont = toFont(options.bodyFont);
  const titleFont = toFont(options.titleFont);
  const footerFont = toFont(options.footerFont);
  const titleLineCount = title.length;
  const footerLineCount = footer.length;
  const bodyLineItemCount = body.length;
  const padding = toPadding(options.padding);
  let height = padding.height;
  let width = 0;
  let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);
  combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;
  if (titleLineCount) {
    height += titleLineCount * titleFont.lineHeight + (titleLineCount - 1) * options.titleSpacing + options.titleMarginBottom;
  }
  if (combinedBodyLength) {
    const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;
    height += bodyLineItemCount * bodyLineHeight + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight + (combinedBodyLength - 1) * options.bodySpacing;
  }
  if (footerLineCount) {
    height += options.footerMarginTop + footerLineCount * footerFont.lineHeight + (footerLineCount - 1) * options.footerSpacing;
  }
  let widthPadding = 0;
  const maxLineWidth = function(line) {
    width = Math.max(width, ctx.measureText(line).width + widthPadding);
  };
  ctx.save();
  ctx.font = titleFont.string;
  each(tooltip.title, maxLineWidth);
  ctx.font = bodyFont.string;
  each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
  widthPadding = options.displayColors ? boxWidth + 2 + options.boxPadding : 0;
  each(body, (bodyItem) => {
    each(bodyItem.before, maxLineWidth);
    each(bodyItem.lines, maxLineWidth);
    each(bodyItem.after, maxLineWidth);
  });
  widthPadding = 0;
  ctx.font = footerFont.string;
  each(tooltip.footer, maxLineWidth);
  ctx.restore();
  width += padding.width;
  return {
    width,
    height
  };
}
function determineYAlign(chart, size) {
  const { y: y2, height } = size;
  if (y2 < height / 2) {
    return "top";
  } else if (y2 > chart.height - height / 2) {
    return "bottom";
  }
  return "center";
}
function doesNotFitWithAlign(xAlign, chart, options, size) {
  const { x: x2, width } = size;
  const caret = options.caretSize + options.caretPadding;
  if (xAlign === "left" && x2 + width + caret > chart.width) {
    return true;
  }
  if (xAlign === "right" && x2 - width - caret < 0) {
    return true;
  }
}
function determineXAlign(chart, options, size, yAlign) {
  const { x: x2, width } = size;
  const { width: chartWidth, chartArea: { left, right } } = chart;
  let xAlign = "center";
  if (yAlign === "center") {
    xAlign = x2 <= (left + right) / 2 ? "left" : "right";
  } else if (x2 <= width / 2) {
    xAlign = "left";
  } else if (x2 >= chartWidth - width / 2) {
    xAlign = "right";
  }
  if (doesNotFitWithAlign(xAlign, chart, options, size)) {
    xAlign = "center";
  }
  return xAlign;
}
function determineAlignment(chart, options, size) {
  const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);
  return {
    xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),
    yAlign
  };
}
function alignX(size, xAlign) {
  let { x: x2, width } = size;
  if (xAlign === "right") {
    x2 -= width;
  } else if (xAlign === "center") {
    x2 -= width / 2;
  }
  return x2;
}
function alignY(size, yAlign, paddingAndSize) {
  let { y: y2, height } = size;
  if (yAlign === "top") {
    y2 += paddingAndSize;
  } else if (yAlign === "bottom") {
    y2 -= height + paddingAndSize;
  } else {
    y2 -= height / 2;
  }
  return y2;
}
function getBackgroundPoint(options, size, alignment, chart) {
  const { caretSize, caretPadding, cornerRadius } = options;
  const { xAlign, yAlign } = alignment;
  const paddingAndSize = caretSize + caretPadding;
  const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(cornerRadius);
  let x2 = alignX(size, xAlign);
  const y2 = alignY(size, yAlign, paddingAndSize);
  if (yAlign === "center") {
    if (xAlign === "left") {
      x2 += paddingAndSize;
    } else if (xAlign === "right") {
      x2 -= paddingAndSize;
    }
  } else if (xAlign === "left") {
    x2 -= Math.max(topLeft, bottomLeft) + caretSize;
  } else if (xAlign === "right") {
    x2 += Math.max(topRight, bottomRight) + caretSize;
  }
  return {
    x: _limitValue(x2, 0, chart.width - size.width),
    y: _limitValue(y2, 0, chart.height - size.height)
  };
}
function getAlignedX(tooltip, align, options) {
  const padding = toPadding(options.padding);
  return align === "center" ? tooltip.x + tooltip.width / 2 : align === "right" ? tooltip.x + tooltip.width - padding.right : tooltip.x + padding.left;
}
function getBeforeAfterBodyLines(callback2) {
  return pushOrConcat([], splitNewlines(callback2));
}
function createTooltipContext(parent, tooltip, tooltipItems) {
  return createContext(parent, {
    tooltip,
    tooltipItems,
    type: "tooltip"
  });
}
function overrideCallbacks(callbacks, context) {
  const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;
  return override ? callbacks.override(override) : callbacks;
}
var defaultCallbacks = {
  beforeTitle: noop,
  title(tooltipItems) {
    if (tooltipItems.length > 0) {
      const item = tooltipItems[0];
      const labels = item.chart.data.labels;
      const labelCount = labels ? labels.length : 0;
      if (this && this.options && this.options.mode === "dataset") {
        return item.dataset.label || "";
      } else if (item.label) {
        return item.label;
      } else if (labelCount > 0 && item.dataIndex < labelCount) {
        return labels[item.dataIndex];
      }
    }
    return "";
  },
  afterTitle: noop,
  beforeBody: noop,
  beforeLabel: noop,
  label(tooltipItem) {
    if (this && this.options && this.options.mode === "dataset") {
      return tooltipItem.label + ": " + tooltipItem.formattedValue || tooltipItem.formattedValue;
    }
    let label = tooltipItem.dataset.label || "";
    if (label) {
      label += ": ";
    }
    const value = tooltipItem.formattedValue;
    if (!isNullOrUndef(value)) {
      label += value;
    }
    return label;
  },
  labelColor(tooltipItem) {
    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
    const options = meta.controller.getStyle(tooltipItem.dataIndex);
    return {
      borderColor: options.borderColor,
      backgroundColor: options.backgroundColor,
      borderWidth: options.borderWidth,
      borderDash: options.borderDash,
      borderDashOffset: options.borderDashOffset,
      borderRadius: 0
    };
  },
  labelTextColor() {
    return this.options.bodyColor;
  },
  labelPointStyle(tooltipItem) {
    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
    const options = meta.controller.getStyle(tooltipItem.dataIndex);
    return {
      pointStyle: options.pointStyle,
      rotation: options.rotation
    };
  },
  afterLabel: noop,
  afterBody: noop,
  beforeFooter: noop,
  footer: noop,
  afterFooter: noop
};
function invokeCallbackWithFallback(callbacks, name, ctx, arg) {
  const result = callbacks[name].call(ctx, arg);
  if (typeof result === "undefined") {
    return defaultCallbacks[name].call(ctx, arg);
  }
  return result;
}
var Tooltip = class extends Element {
  constructor(config) {
    super();
    this.opacity = 0;
    this._active = [];
    this._eventPosition = void 0;
    this._size = void 0;
    this._cachedAnimations = void 0;
    this._tooltipItems = [];
    this.$animations = void 0;
    this.$context = void 0;
    this.chart = config.chart;
    this.options = config.options;
    this.dataPoints = void 0;
    this.title = void 0;
    this.beforeBody = void 0;
    this.body = void 0;
    this.afterBody = void 0;
    this.footer = void 0;
    this.xAlign = void 0;
    this.yAlign = void 0;
    this.x = void 0;
    this.y = void 0;
    this.height = void 0;
    this.width = void 0;
    this.caretX = void 0;
    this.caretY = void 0;
    this.labelColors = void 0;
    this.labelPointStyles = void 0;
    this.labelTextColors = void 0;
  }
  initialize(options) {
    this.options = options;
    this._cachedAnimations = void 0;
    this.$context = void 0;
  }
  _resolveAnimations() {
    const cached = this._cachedAnimations;
    if (cached) {
      return cached;
    }
    const chart = this.chart;
    const options = this.options.setContext(this.getContext());
    const opts = options.enabled && chart.options.animation && options.animations;
    const animations = new Animations(this.chart, opts);
    if (opts._cacheable) {
      this._cachedAnimations = Object.freeze(animations);
    }
    return animations;
  }
  getContext() {
    return this.$context || (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));
  }
  getTitle(context, options) {
    const { callbacks } = options;
    const beforeTitle = invokeCallbackWithFallback(callbacks, "beforeTitle", this, context);
    const title = invokeCallbackWithFallback(callbacks, "title", this, context);
    const afterTitle = invokeCallbackWithFallback(callbacks, "afterTitle", this, context);
    let lines = [];
    lines = pushOrConcat(lines, splitNewlines(beforeTitle));
    lines = pushOrConcat(lines, splitNewlines(title));
    lines = pushOrConcat(lines, splitNewlines(afterTitle));
    return lines;
  }
  getBeforeBody(tooltipItems, options) {
    return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, "beforeBody", this, tooltipItems));
  }
  getBody(tooltipItems, options) {
    const { callbacks } = options;
    const bodyItems = [];
    each(tooltipItems, (context) => {
      const bodyItem = {
        before: [],
        lines: [],
        after: []
      };
      const scoped = overrideCallbacks(callbacks, context);
      pushOrConcat(bodyItem.before, splitNewlines(invokeCallbackWithFallback(scoped, "beforeLabel", this, context)));
      pushOrConcat(bodyItem.lines, invokeCallbackWithFallback(scoped, "label", this, context));
      pushOrConcat(bodyItem.after, splitNewlines(invokeCallbackWithFallback(scoped, "afterLabel", this, context)));
      bodyItems.push(bodyItem);
    });
    return bodyItems;
  }
  getAfterBody(tooltipItems, options) {
    return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, "afterBody", this, tooltipItems));
  }
  getFooter(tooltipItems, options) {
    const { callbacks } = options;
    const beforeFooter = invokeCallbackWithFallback(callbacks, "beforeFooter", this, tooltipItems);
    const footer = invokeCallbackWithFallback(callbacks, "footer", this, tooltipItems);
    const afterFooter = invokeCallbackWithFallback(callbacks, "afterFooter", this, tooltipItems);
    let lines = [];
    lines = pushOrConcat(lines, splitNewlines(beforeFooter));
    lines = pushOrConcat(lines, splitNewlines(footer));
    lines = pushOrConcat(lines, splitNewlines(afterFooter));
    return lines;
  }
  _createItems(options) {
    const active = this._active;
    const data = this.chart.data;
    const labelColors = [];
    const labelPointStyles = [];
    const labelTextColors = [];
    let tooltipItems = [];
    let i2, len;
    for (i2 = 0, len = active.length; i2 < len; ++i2) {
      tooltipItems.push(createTooltipItem(this.chart, active[i2]));
    }
    if (options.filter) {
      tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));
    }
    if (options.itemSort) {
      tooltipItems = tooltipItems.sort((a2, b2) => options.itemSort(a2, b2, data));
    }
    each(tooltipItems, (context) => {
      const scoped = overrideCallbacks(options.callbacks, context);
      labelColors.push(invokeCallbackWithFallback(scoped, "labelColor", this, context));
      labelPointStyles.push(invokeCallbackWithFallback(scoped, "labelPointStyle", this, context));
      labelTextColors.push(invokeCallbackWithFallback(scoped, "labelTextColor", this, context));
    });
    this.labelColors = labelColors;
    this.labelPointStyles = labelPointStyles;
    this.labelTextColors = labelTextColors;
    this.dataPoints = tooltipItems;
    return tooltipItems;
  }
  update(changed, replay) {
    const options = this.options.setContext(this.getContext());
    const active = this._active;
    let properties;
    let tooltipItems = [];
    if (!active.length) {
      if (this.opacity !== 0) {
        properties = {
          opacity: 0
        };
      }
    } else {
      const position = positioners[options.position].call(this, active, this._eventPosition);
      tooltipItems = this._createItems(options);
      this.title = this.getTitle(tooltipItems, options);
      this.beforeBody = this.getBeforeBody(tooltipItems, options);
      this.body = this.getBody(tooltipItems, options);
      this.afterBody = this.getAfterBody(tooltipItems, options);
      this.footer = this.getFooter(tooltipItems, options);
      const size = this._size = getTooltipSize(this, options);
      const positionAndSize = Object.assign({}, position, size);
      const alignment = determineAlignment(this.chart, options, positionAndSize);
      const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);
      this.xAlign = alignment.xAlign;
      this.yAlign = alignment.yAlign;
      properties = {
        opacity: 1,
        x: backgroundPoint.x,
        y: backgroundPoint.y,
        width: size.width,
        height: size.height,
        caretX: position.x,
        caretY: position.y
      };
    }
    this._tooltipItems = tooltipItems;
    this.$context = void 0;
    if (properties) {
      this._resolveAnimations().update(this, properties);
    }
    if (changed && options.external) {
      options.external.call(this, {
        chart: this.chart,
        tooltip: this,
        replay
      });
    }
  }
  drawCaret(tooltipPoint, ctx, size, options) {
    const caretPosition = this.getCaretPosition(tooltipPoint, size, options);
    ctx.lineTo(caretPosition.x1, caretPosition.y1);
    ctx.lineTo(caretPosition.x2, caretPosition.y2);
    ctx.lineTo(caretPosition.x3, caretPosition.y3);
  }
  getCaretPosition(tooltipPoint, size, options) {
    const { xAlign, yAlign } = this;
    const { caretSize, cornerRadius } = options;
    const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(cornerRadius);
    const { x: ptX, y: ptY } = tooltipPoint;
    const { width, height } = size;
    let x1, x2, x3, y1, y2, y3;
    if (yAlign === "center") {
      y2 = ptY + height / 2;
      if (xAlign === "left") {
        x1 = ptX;
        x2 = x1 - caretSize;
        y1 = y2 + caretSize;
        y3 = y2 - caretSize;
      } else {
        x1 = ptX + width;
        x2 = x1 + caretSize;
        y1 = y2 - caretSize;
        y3 = y2 + caretSize;
      }
      x3 = x1;
    } else {
      if (xAlign === "left") {
        x2 = ptX + Math.max(topLeft, bottomLeft) + caretSize;
      } else if (xAlign === "right") {
        x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;
      } else {
        x2 = this.caretX;
      }
      if (yAlign === "top") {
        y1 = ptY;
        y2 = y1 - caretSize;
        x1 = x2 - caretSize;
        x3 = x2 + caretSize;
      } else {
        y1 = ptY + height;
        y2 = y1 + caretSize;
        x1 = x2 + caretSize;
        x3 = x2 - caretSize;
      }
      y3 = y1;
    }
    return {
      x1,
      x2,
      x3,
      y1,
      y2,
      y3
    };
  }
  drawTitle(pt3, ctx, options) {
    const title = this.title;
    const length = title.length;
    let titleFont, titleSpacing, i2;
    if (length) {
      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
      pt3.x = getAlignedX(this, options.titleAlign, options);
      ctx.textAlign = rtlHelper.textAlign(options.titleAlign);
      ctx.textBaseline = "middle";
      titleFont = toFont(options.titleFont);
      titleSpacing = options.titleSpacing;
      ctx.fillStyle = options.titleColor;
      ctx.font = titleFont.string;
      for (i2 = 0; i2 < length; ++i2) {
        ctx.fillText(title[i2], rtlHelper.x(pt3.x), pt3.y + titleFont.lineHeight / 2);
        pt3.y += titleFont.lineHeight + titleSpacing;
        if (i2 + 1 === length) {
          pt3.y += options.titleMarginBottom - titleSpacing;
        }
      }
    }
  }
  _drawColorBox(ctx, pt3, i2, rtlHelper, options) {
    const labelColor = this.labelColors[i2];
    const labelPointStyle = this.labelPointStyles[i2];
    const { boxHeight, boxWidth } = options;
    const bodyFont = toFont(options.bodyFont);
    const colorX = getAlignedX(this, "left", options);
    const rtlColorX = rtlHelper.x(colorX);
    const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;
    const colorY = pt3.y + yOffSet;
    if (options.usePointStyle) {
      const drawOptions = {
        radius: Math.min(boxWidth, boxHeight) / 2,
        pointStyle: labelPointStyle.pointStyle,
        rotation: labelPointStyle.rotation,
        borderWidth: 1
      };
      const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;
      const centerY = colorY + boxHeight / 2;
      ctx.strokeStyle = options.multiKeyBackground;
      ctx.fillStyle = options.multiKeyBackground;
      drawPoint(ctx, drawOptions, centerX, centerY);
      ctx.strokeStyle = labelColor.borderColor;
      ctx.fillStyle = labelColor.backgroundColor;
      drawPoint(ctx, drawOptions, centerX, centerY);
    } else {
      ctx.lineWidth = isObject(labelColor.borderWidth) ? Math.max(...Object.values(labelColor.borderWidth)) : labelColor.borderWidth || 1;
      ctx.strokeStyle = labelColor.borderColor;
      ctx.setLineDash(labelColor.borderDash || []);
      ctx.lineDashOffset = labelColor.borderDashOffset || 0;
      const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth);
      const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2);
      const borderRadius = toTRBLCorners(labelColor.borderRadius);
      if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
        ctx.beginPath();
        ctx.fillStyle = options.multiKeyBackground;
        addRoundedRectPath(ctx, {
          x: outerX,
          y: colorY,
          w: boxWidth,
          h: boxHeight,
          radius: borderRadius
        });
        ctx.fill();
        ctx.stroke();
        ctx.fillStyle = labelColor.backgroundColor;
        ctx.beginPath();
        addRoundedRectPath(ctx, {
          x: innerX,
          y: colorY + 1,
          w: boxWidth - 2,
          h: boxHeight - 2,
          radius: borderRadius
        });
        ctx.fill();
      } else {
        ctx.fillStyle = options.multiKeyBackground;
        ctx.fillRect(outerX, colorY, boxWidth, boxHeight);
        ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);
        ctx.fillStyle = labelColor.backgroundColor;
        ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);
      }
    }
    ctx.fillStyle = this.labelTextColors[i2];
  }
  drawBody(pt3, ctx, options) {
    const { body } = this;
    const { bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding } = options;
    const bodyFont = toFont(options.bodyFont);
    let bodyLineHeight = bodyFont.lineHeight;
    let xLinePadding = 0;
    const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
    const fillLineOfText = function(line) {
      ctx.fillText(line, rtlHelper.x(pt3.x + xLinePadding), pt3.y + bodyLineHeight / 2);
      pt3.y += bodyLineHeight + bodySpacing;
    };
    const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);
    let bodyItem, textColor, lines, i2, j2, ilen, jlen;
    ctx.textAlign = bodyAlign;
    ctx.textBaseline = "middle";
    ctx.font = bodyFont.string;
    pt3.x = getAlignedX(this, bodyAlignForCalculation, options);
    ctx.fillStyle = options.bodyColor;
    each(this.beforeBody, fillLineOfText);
    xLinePadding = displayColors && bodyAlignForCalculation !== "right" ? bodyAlign === "center" ? boxWidth / 2 + boxPadding : boxWidth + 2 + boxPadding : 0;
    for (i2 = 0, ilen = body.length; i2 < ilen; ++i2) {
      bodyItem = body[i2];
      textColor = this.labelTextColors[i2];
      ctx.fillStyle = textColor;
      each(bodyItem.before, fillLineOfText);
      lines = bodyItem.lines;
      if (displayColors && lines.length) {
        this._drawColorBox(ctx, pt3, i2, rtlHelper, options);
        bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);
      }
      for (j2 = 0, jlen = lines.length; j2 < jlen; ++j2) {
        fillLineOfText(lines[j2]);
        bodyLineHeight = bodyFont.lineHeight;
      }
      each(bodyItem.after, fillLineOfText);
    }
    xLinePadding = 0;
    bodyLineHeight = bodyFont.lineHeight;
    each(this.afterBody, fillLineOfText);
    pt3.y -= bodySpacing;
  }
  drawFooter(pt3, ctx, options) {
    const footer = this.footer;
    const length = footer.length;
    let footerFont, i2;
    if (length) {
      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
      pt3.x = getAlignedX(this, options.footerAlign, options);
      pt3.y += options.footerMarginTop;
      ctx.textAlign = rtlHelper.textAlign(options.footerAlign);
      ctx.textBaseline = "middle";
      footerFont = toFont(options.footerFont);
      ctx.fillStyle = options.footerColor;
      ctx.font = footerFont.string;
      for (i2 = 0; i2 < length; ++i2) {
        ctx.fillText(footer[i2], rtlHelper.x(pt3.x), pt3.y + footerFont.lineHeight / 2);
        pt3.y += footerFont.lineHeight + options.footerSpacing;
      }
    }
  }
  drawBackground(pt3, ctx, tooltipSize, options) {
    const { xAlign, yAlign } = this;
    const { x: x2, y: y2 } = pt3;
    const { width, height } = tooltipSize;
    const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(options.cornerRadius);
    ctx.fillStyle = options.backgroundColor;
    ctx.strokeStyle = options.borderColor;
    ctx.lineWidth = options.borderWidth;
    ctx.beginPath();
    ctx.moveTo(x2 + topLeft, y2);
    if (yAlign === "top") {
      this.drawCaret(pt3, ctx, tooltipSize, options);
    }
    ctx.lineTo(x2 + width - topRight, y2);
    ctx.quadraticCurveTo(x2 + width, y2, x2 + width, y2 + topRight);
    if (yAlign === "center" && xAlign === "right") {
      this.drawCaret(pt3, ctx, tooltipSize, options);
    }
    ctx.lineTo(x2 + width, y2 + height - bottomRight);
    ctx.quadraticCurveTo(x2 + width, y2 + height, x2 + width - bottomRight, y2 + height);
    if (yAlign === "bottom") {
      this.drawCaret(pt3, ctx, tooltipSize, options);
    }
    ctx.lineTo(x2 + bottomLeft, y2 + height);
    ctx.quadraticCurveTo(x2, y2 + height, x2, y2 + height - bottomLeft);
    if (yAlign === "center" && xAlign === "left") {
      this.drawCaret(pt3, ctx, tooltipSize, options);
    }
    ctx.lineTo(x2, y2 + topLeft);
    ctx.quadraticCurveTo(x2, y2, x2 + topLeft, y2);
    ctx.closePath();
    ctx.fill();
    if (options.borderWidth > 0) {
      ctx.stroke();
    }
  }
  _updateAnimationTarget(options) {
    const chart = this.chart;
    const anims = this.$animations;
    const animX = anims && anims.x;
    const animY = anims && anims.y;
    if (animX || animY) {
      const position = positioners[options.position].call(this, this._active, this._eventPosition);
      if (!position) {
        return;
      }
      const size = this._size = getTooltipSize(this, options);
      const positionAndSize = Object.assign({}, position, this._size);
      const alignment = determineAlignment(chart, options, positionAndSize);
      const point = getBackgroundPoint(options, positionAndSize, alignment, chart);
      if (animX._to !== point.x || animY._to !== point.y) {
        this.xAlign = alignment.xAlign;
        this.yAlign = alignment.yAlign;
        this.width = size.width;
        this.height = size.height;
        this.caretX = position.x;
        this.caretY = position.y;
        this._resolveAnimations().update(this, point);
      }
    }
  }
  _willRender() {
    return !!this.opacity;
  }
  draw(ctx) {
    const options = this.options.setContext(this.getContext());
    let opacity = this.opacity;
    if (!opacity) {
      return;
    }
    this._updateAnimationTarget(options);
    const tooltipSize = {
      width: this.width,
      height: this.height
    };
    const pt3 = {
      x: this.x,
      y: this.y
    };
    opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;
    const padding = toPadding(options.padding);
    const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;
    if (options.enabled && hasTooltipContent) {
      ctx.save();
      ctx.globalAlpha = opacity;
      this.drawBackground(pt3, ctx, tooltipSize, options);
      overrideTextDirection(ctx, options.textDirection);
      pt3.y += padding.top;
      this.drawTitle(pt3, ctx, options);
      this.drawBody(pt3, ctx, options);
      this.drawFooter(pt3, ctx, options);
      restoreTextDirection(ctx, options.textDirection);
      ctx.restore();
    }
  }
  getActiveElements() {
    return this._active || [];
  }
  setActiveElements(activeElements, eventPosition) {
    const lastActive = this._active;
    const active = activeElements.map(({ datasetIndex, index }) => {
      const meta = this.chart.getDatasetMeta(datasetIndex);
      if (!meta) {
        throw new Error("Cannot find a dataset at index " + datasetIndex);
      }
      return {
        datasetIndex,
        element: meta.data[index],
        index
      };
    });
    const changed = !_elementsEqual(lastActive, active);
    const positionChanged = this._positionChanged(active, eventPosition);
    if (changed || positionChanged) {
      this._active = active;
      this._eventPosition = eventPosition;
      this._ignoreReplayEvents = true;
      this.update(true);
    }
  }
  handleEvent(e2, replay, inChartArea = true) {
    if (replay && this._ignoreReplayEvents) {
      return false;
    }
    this._ignoreReplayEvents = false;
    const options = this.options;
    const lastActive = this._active || [];
    const active = this._getActiveElements(e2, lastActive, replay, inChartArea);
    const positionChanged = this._positionChanged(active, e2);
    const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
    if (changed) {
      this._active = active;
      if (options.enabled || options.external) {
        this._eventPosition = {
          x: e2.x,
          y: e2.y
        };
        this.update(true, replay);
      }
    }
    return changed;
  }
  _getActiveElements(e2, lastActive, replay, inChartArea) {
    const options = this.options;
    if (e2.type === "mouseout") {
      return [];
    }
    if (!inChartArea) {
      return lastActive.filter((i2) => this.chart.data.datasets[i2.datasetIndex] && this.chart.getDatasetMeta(i2.datasetIndex).controller.getParsed(i2.index) !== void 0);
    }
    const active = this.chart.getElementsAtEventForMode(e2, options.mode, options, replay);
    if (options.reverse) {
      active.reverse();
    }
    return active;
  }
  _positionChanged(active, e2) {
    const { caretX, caretY, options } = this;
    const position = positioners[options.position].call(this, active, e2);
    return position !== false && (caretX !== position.x || caretY !== position.y);
  }
};
__publicField(Tooltip, "positioners", positioners);
var plugin_tooltip = {
  id: "tooltip",
  _element: Tooltip,
  positioners,
  afterInit(chart, _args, options) {
    if (options) {
      chart.tooltip = new Tooltip({
        chart,
        options
      });
    }
  },
  beforeUpdate(chart, _args, options) {
    if (chart.tooltip) {
      chart.tooltip.initialize(options);
    }
  },
  reset(chart, _args, options) {
    if (chart.tooltip) {
      chart.tooltip.initialize(options);
    }
  },
  afterDraw(chart) {
    const tooltip = chart.tooltip;
    if (tooltip && tooltip._willRender()) {
      const args = {
        tooltip
      };
      if (chart.notifyPlugins("beforeTooltipDraw", {
        ...args,
        cancelable: true
      }) === false) {
        return;
      }
      tooltip.draw(chart.ctx);
      chart.notifyPlugins("afterTooltipDraw", args);
    }
  },
  afterEvent(chart, args) {
    if (chart.tooltip) {
      const useFinalPosition = args.replay;
      if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {
        args.changed = true;
      }
    }
  },
  defaults: {
    enabled: true,
    external: null,
    position: "average",
    backgroundColor: "rgba(0,0,0,0.8)",
    titleColor: "#fff",
    titleFont: {
      weight: "bold"
    },
    titleSpacing: 2,
    titleMarginBottom: 6,
    titleAlign: "left",
    bodyColor: "#fff",
    bodySpacing: 2,
    bodyFont: {},
    bodyAlign: "left",
    footerColor: "#fff",
    footerSpacing: 2,
    footerMarginTop: 6,
    footerFont: {
      weight: "bold"
    },
    footerAlign: "left",
    padding: 6,
    caretPadding: 2,
    caretSize: 5,
    cornerRadius: 6,
    boxHeight: (ctx, opts) => opts.bodyFont.size,
    boxWidth: (ctx, opts) => opts.bodyFont.size,
    multiKeyBackground: "#fff",
    displayColors: true,
    boxPadding: 0,
    borderColor: "rgba(0,0,0,0)",
    borderWidth: 0,
    animation: {
      duration: 400,
      easing: "easeOutQuart"
    },
    animations: {
      numbers: {
        type: "number",
        properties: [
          "x",
          "y",
          "width",
          "height",
          "caretX",
          "caretY"
        ]
      },
      opacity: {
        easing: "linear",
        duration: 200
      }
    },
    callbacks: defaultCallbacks
  },
  defaultRoutes: {
    bodyFont: "font",
    footerFont: "font",
    titleFont: "font"
  },
  descriptors: {
    _scriptable: (name) => name !== "filter" && name !== "itemSort" && name !== "external",
    _indexable: false,
    callbacks: {
      _scriptable: false,
      _indexable: false
    },
    animation: {
      _fallback: false
    },
    animations: {
      _fallback: "animation"
    }
  },
  additionalOptionScopes: [
    "interaction"
  ]
};
var addIfString = (labels, raw, index, addedLabels) => {
  if (typeof raw === "string") {
    index = labels.push(raw) - 1;
    addedLabels.unshift({
      index,
      label: raw
    });
  } else if (isNaN(raw)) {
    index = null;
  }
  return index;
};
function findOrAddLabel(labels, raw, index, addedLabels) {
  const first = labels.indexOf(raw);
  if (first === -1) {
    return addIfString(labels, raw, index, addedLabels);
  }
  const last = labels.lastIndexOf(raw);
  return first !== last ? index : first;
}
var validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);
function _getLabelForValue(value) {
  const labels = this.getLabels();
  if (value >= 0 && value < labels.length) {
    return labels[value];
  }
  return value;
}
var CategoryScale = class extends Scale {
  constructor(cfg) {
    super(cfg);
    this._startValue = void 0;
    this._valueRange = 0;
    this._addedLabels = [];
  }
  init(scaleOptions) {
    const added = this._addedLabels;
    if (added.length) {
      const labels = this.getLabels();
      for (const { index, label } of added) {
        if (labels[index] === label) {
          labels.splice(index, 1);
        }
      }
      this._addedLabels = [];
    }
    super.init(scaleOptions);
  }
  parse(raw, index) {
    if (isNullOrUndef(raw)) {
      return null;
    }
    const labels = this.getLabels();
    index = isFinite(index) && labels[index] === raw ? index : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);
    return validIndex(index, labels.length - 1);
  }
  determineDataLimits() {
    const { minDefined, maxDefined } = this.getUserBounds();
    let { min, max } = this.getMinMax(true);
    if (this.options.bounds === "ticks") {
      if (!minDefined) {
        min = 0;
      }
      if (!maxDefined) {
        max = this.getLabels().length - 1;
      }
    }
    this.min = min;
    this.max = max;
  }
  buildTicks() {
    const min = this.min;
    const max = this.max;
    const offset = this.options.offset;
    const ticks = [];
    let labels = this.getLabels();
    labels = min === 0 && max === labels.length - 1 ? labels : labels.slice(min, max + 1);
    this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);
    this._startValue = this.min - (offset ? 0.5 : 0);
    for (let value = min; value <= max; value++) {
      ticks.push({
        value
      });
    }
    return ticks;
  }
  getLabelForValue(value) {
    return _getLabelForValue.call(this, value);
  }
  configure() {
    super.configure();
    if (!this.isHorizontal()) {
      this._reversePixels = !this._reversePixels;
    }
  }
  getPixelForValue(value) {
    if (typeof value !== "number") {
      value = this.parse(value);
    }
    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
  }
  getPixelForTick(index) {
    const ticks = this.ticks;
    if (index < 0 || index > ticks.length - 1) {
      return null;
    }
    return this.getPixelForValue(ticks[index].value);
  }
  getValueForPixel(pixel) {
    return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);
  }
  getBasePixel() {
    return this.bottom;
  }
};
__publicField(CategoryScale, "id", "category");
__publicField(CategoryScale, "defaults", {
  ticks: {
    callback: _getLabelForValue
  }
});
function generateTicks$1(generationOptions, dataRange) {
  const ticks = [];
  const MIN_SPACING = 1e-14;
  const { bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds } = generationOptions;
  const unit = step || 1;
  const maxSpaces = maxTicks - 1;
  const { min: rmin, max: rmax } = dataRange;
  const minDefined = !isNullOrUndef(min);
  const maxDefined = !isNullOrUndef(max);
  const countDefined = !isNullOrUndef(count);
  const minSpacing = (rmax - rmin) / (maxDigits + 1);
  let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;
  let factor, niceMin, niceMax, numSpaces;
  if (spacing < MIN_SPACING && !minDefined && !maxDefined) {
    return [
      {
        value: rmin
      },
      {
        value: rmax
      }
    ];
  }
  numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);
  if (numSpaces > maxSpaces) {
    spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;
  }
  if (!isNullOrUndef(precision)) {
    factor = Math.pow(10, precision);
    spacing = Math.ceil(spacing * factor) / factor;
  }
  if (bounds === "ticks") {
    niceMin = Math.floor(rmin / spacing) * spacing;
    niceMax = Math.ceil(rmax / spacing) * spacing;
  } else {
    niceMin = rmin;
    niceMax = rmax;
  }
  if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1e3)) {
    numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));
    spacing = (max - min) / numSpaces;
    niceMin = min;
    niceMax = max;
  } else if (countDefined) {
    niceMin = minDefined ? min : niceMin;
    niceMax = maxDefined ? max : niceMax;
    numSpaces = count - 1;
    spacing = (niceMax - niceMin) / numSpaces;
  } else {
    numSpaces = (niceMax - niceMin) / spacing;
    if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1e3)) {
      numSpaces = Math.round(numSpaces);
    } else {
      numSpaces = Math.ceil(numSpaces);
    }
  }
  const decimalPlaces = Math.max(_decimalPlaces(spacing), _decimalPlaces(niceMin));
  factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);
  niceMin = Math.round(niceMin * factor) / factor;
  niceMax = Math.round(niceMax * factor) / factor;
  let j2 = 0;
  if (minDefined) {
    if (includeBounds && niceMin !== min) {
      ticks.push({
        value: min
      });
      if (niceMin < min) {
        j2++;
      }
      if (almostEquals(Math.round((niceMin + j2 * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {
        j2++;
      }
    } else if (niceMin < min) {
      j2++;
    }
  }
  for (; j2 < numSpaces; ++j2) {
    const tickValue = Math.round((niceMin + j2 * spacing) * factor) / factor;
    if (maxDefined && tickValue > max) {
      break;
    }
    ticks.push({
      value: tickValue
    });
  }
  if (maxDefined && includeBounds && niceMax !== max) {
    if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {
      ticks[ticks.length - 1].value = max;
    } else {
      ticks.push({
        value: max
      });
    }
  } else if (!maxDefined || niceMax === max) {
    ticks.push({
      value: niceMax
    });
  }
  return ticks;
}
function relativeLabelSize(value, minSpacing, { horizontal, minRotation }) {
  const rad = toRadians(minRotation);
  const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 1e-3;
  const length = 0.75 * minSpacing * ("" + value).length;
  return Math.min(minSpacing / ratio, length);
}
var LinearScaleBase = class extends Scale {
  constructor(cfg) {
    super(cfg);
    this.start = void 0;
    this.end = void 0;
    this._startValue = void 0;
    this._endValue = void 0;
    this._valueRange = 0;
  }
  parse(raw, index) {
    if (isNullOrUndef(raw)) {
      return null;
    }
    if ((typeof raw === "number" || raw instanceof Number) && !isFinite(+raw)) {
      return null;
    }
    return +raw;
  }
  handleTickRangeOptions() {
    const { beginAtZero } = this.options;
    const { minDefined, maxDefined } = this.getUserBounds();
    let { min, max } = this;
    const setMin = (v2) => min = minDefined ? min : v2;
    const setMax = (v2) => max = maxDefined ? max : v2;
    if (beginAtZero) {
      const minSign = sign(min);
      const maxSign = sign(max);
      if (minSign < 0 && maxSign < 0) {
        setMax(0);
      } else if (minSign > 0 && maxSign > 0) {
        setMin(0);
      }
    }
    if (min === max) {
      let offset = max === 0 ? 1 : Math.abs(max * 0.05);
      setMax(max + offset);
      if (!beginAtZero) {
        setMin(min - offset);
      }
    }
    this.min = min;
    this.max = max;
  }
  getTickLimit() {
    const tickOpts = this.options.ticks;
    let { maxTicksLimit, stepSize } = tickOpts;
    let maxTicks;
    if (stepSize) {
      maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;
      if (maxTicks > 1e3) {
        console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);
        maxTicks = 1e3;
      }
    } else {
      maxTicks = this.computeTickLimit();
      maxTicksLimit = maxTicksLimit || 11;
    }
    if (maxTicksLimit) {
      maxTicks = Math.min(maxTicksLimit, maxTicks);
    }
    return maxTicks;
  }
  computeTickLimit() {
    return Number.POSITIVE_INFINITY;
  }
  buildTicks() {
    const opts = this.options;
    const tickOpts = opts.ticks;
    let maxTicks = this.getTickLimit();
    maxTicks = Math.max(2, maxTicks);
    const numericGeneratorOptions = {
      maxTicks,
      bounds: opts.bounds,
      min: opts.min,
      max: opts.max,
      precision: tickOpts.precision,
      step: tickOpts.stepSize,
      count: tickOpts.count,
      maxDigits: this._maxDigits(),
      horizontal: this.isHorizontal(),
      minRotation: tickOpts.minRotation || 0,
      includeBounds: tickOpts.includeBounds !== false
    };
    const dataRange = this._range || this;
    const ticks = generateTicks$1(numericGeneratorOptions, dataRange);
    if (opts.bounds === "ticks") {
      _setMinAndMaxByKey(ticks, this, "value");
    }
    if (opts.reverse) {
      ticks.reverse();
      this.start = this.max;
      this.end = this.min;
    } else {
      this.start = this.min;
      this.end = this.max;
    }
    return ticks;
  }
  configure() {
    const ticks = this.ticks;
    let start = this.min;
    let end = this.max;
    super.configure();
    if (this.options.offset && ticks.length) {
      const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;
      start -= offset;
      end += offset;
    }
    this._startValue = start;
    this._endValue = end;
    this._valueRange = end - start;
  }
  getLabelForValue(value) {
    return formatNumber(value, this.chart.options.locale, this.options.ticks.format);
  }
};
var LinearScale = class extends LinearScaleBase {
  determineDataLimits() {
    const { min, max } = this.getMinMax(true);
    this.min = isNumberFinite(min) ? min : 0;
    this.max = isNumberFinite(max) ? max : 1;
    this.handleTickRangeOptions();
  }
  computeTickLimit() {
    const horizontal = this.isHorizontal();
    const length = horizontal ? this.width : this.height;
    const minRotation = toRadians(this.options.ticks.minRotation);
    const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 1e-3;
    const tickFont = this._resolveTickFontOptions(0);
    return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));
  }
  getPixelForValue(value) {
    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
  }
  getValueForPixel(pixel) {
    return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;
  }
};
__publicField(LinearScale, "id", "linear");
__publicField(LinearScale, "defaults", {
  ticks: {
    callback: Ticks.formatters.numeric
  }
});
var log10Floor = (v2) => Math.floor(log10(v2));
var changeExponent = (v2, m2) => Math.pow(10, log10Floor(v2) + m2);
function isMajor(tickVal) {
  const remain = tickVal / Math.pow(10, log10Floor(tickVal));
  return remain === 1;
}
function steps(min, max, rangeExp) {
  const rangeStep = Math.pow(10, rangeExp);
  const start = Math.floor(min / rangeStep);
  const end = Math.ceil(max / rangeStep);
  return end - start;
}
function startExp(min, max) {
  const range2 = max - min;
  let rangeExp = log10Floor(range2);
  while (steps(min, max, rangeExp) > 10) {
    rangeExp++;
  }
  while (steps(min, max, rangeExp) < 10) {
    rangeExp--;
  }
  return Math.min(rangeExp, log10Floor(min));
}
function generateTicks(generationOptions, { min, max }) {
  min = finiteOrDefault(generationOptions.min, min);
  const ticks = [];
  const minExp = log10Floor(min);
  let exp = startExp(min, max);
  let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;
  const stepSize = Math.pow(10, exp);
  const base = minExp > exp ? Math.pow(10, minExp) : 0;
  const start = Math.round((min - base) * precision) / precision;
  const offset = Math.floor((min - base) / stepSize / 10) * stepSize * 10;
  let significand = Math.floor((start - offset) / Math.pow(10, exp));
  let value = finiteOrDefault(generationOptions.min, Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision);
  while (value < max) {
    ticks.push({
      value,
      major: isMajor(value),
      significand
    });
    if (significand >= 10) {
      significand = significand < 15 ? 15 : 20;
    } else {
      significand++;
    }
    if (significand >= 20) {
      exp++;
      significand = 2;
      precision = exp >= 0 ? 1 : precision;
    }
    value = Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision;
  }
  const lastTick = finiteOrDefault(generationOptions.max, value);
  ticks.push({
    value: lastTick,
    major: isMajor(lastTick),
    significand
  });
  return ticks;
}
var LogarithmicScale = class extends Scale {
  constructor(cfg) {
    super(cfg);
    this.start = void 0;
    this.end = void 0;
    this._startValue = void 0;
    this._valueRange = 0;
  }
  parse(raw, index) {
    const value = LinearScaleBase.prototype.parse.apply(this, [
      raw,
      index
    ]);
    if (value === 0) {
      this._zero = true;
      return void 0;
    }
    return isNumberFinite(value) && value > 0 ? value : null;
  }
  determineDataLimits() {
    const { min, max } = this.getMinMax(true);
    this.min = isNumberFinite(min) ? Math.max(0, min) : null;
    this.max = isNumberFinite(max) ? Math.max(0, max) : null;
    if (this.options.beginAtZero) {
      this._zero = true;
    }
    if (this._zero && this.min !== this._suggestedMin && !isNumberFinite(this._userMin)) {
      this.min = min === changeExponent(this.min, 0) ? changeExponent(this.min, -1) : changeExponent(this.min, 0);
    }
    this.handleTickRangeOptions();
  }
  handleTickRangeOptions() {
    const { minDefined, maxDefined } = this.getUserBounds();
    let min = this.min;
    let max = this.max;
    const setMin = (v2) => min = minDefined ? min : v2;
    const setMax = (v2) => max = maxDefined ? max : v2;
    if (min === max) {
      if (min <= 0) {
        setMin(1);
        setMax(10);
      } else {
        setMin(changeExponent(min, -1));
        setMax(changeExponent(max, 1));
      }
    }
    if (min <= 0) {
      setMin(changeExponent(max, -1));
    }
    if (max <= 0) {
      setMax(changeExponent(min, 1));
    }
    this.min = min;
    this.max = max;
  }
  buildTicks() {
    const opts = this.options;
    const generationOptions = {
      min: this._userMin,
      max: this._userMax
    };
    const ticks = generateTicks(generationOptions, this);
    if (opts.bounds === "ticks") {
      _setMinAndMaxByKey(ticks, this, "value");
    }
    if (opts.reverse) {
      ticks.reverse();
      this.start = this.max;
      this.end = this.min;
    } else {
      this.start = this.min;
      this.end = this.max;
    }
    return ticks;
  }
  getLabelForValue(value) {
    return value === void 0 ? "0" : formatNumber(value, this.chart.options.locale, this.options.ticks.format);
  }
  configure() {
    const start = this.min;
    super.configure();
    this._startValue = log10(start);
    this._valueRange = log10(this.max) - log10(start);
  }
  getPixelForValue(value) {
    if (value === void 0 || value === 0) {
      value = this.min;
    }
    if (value === null || isNaN(value)) {
      return NaN;
    }
    return this.getPixelForDecimal(value === this.min ? 0 : (log10(value) - this._startValue) / this._valueRange);
  }
  getValueForPixel(pixel) {
    const decimal = this.getDecimalForPixel(pixel);
    return Math.pow(10, this._startValue + decimal * this._valueRange);
  }
};
__publicField(LogarithmicScale, "id", "logarithmic");
__publicField(LogarithmicScale, "defaults", {
  ticks: {
    callback: Ticks.formatters.logarithmic,
    major: {
      enabled: true
    }
  }
});
function getTickBackdropHeight(opts) {
  const tickOpts = opts.ticks;
  if (tickOpts.display && opts.display) {
    const padding = toPadding(tickOpts.backdropPadding);
    return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults2.font.size) + padding.height;
  }
  return 0;
}
function measureLabelSize(ctx, font, label) {
  label = isArray(label) ? label : [
    label
  ];
  return {
    w: _longestText(ctx, font.string, label),
    h: label.length * font.lineHeight
  };
}
function determineLimits(angle, pos, size, min, max) {
  if (angle === min || angle === max) {
    return {
      start: pos - size / 2,
      end: pos + size / 2
    };
  } else if (angle < min || angle > max) {
    return {
      start: pos - size,
      end: pos
    };
  }
  return {
    start: pos,
    end: pos + size
  };
}
function fitWithPointLabels(scale) {
  const orig = {
    l: scale.left + scale._padding.left,
    r: scale.right - scale._padding.right,
    t: scale.top + scale._padding.top,
    b: scale.bottom - scale._padding.bottom
  };
  const limits = Object.assign({}, orig);
  const labelSizes = [];
  const padding = [];
  const valueCount = scale._pointLabels.length;
  const pointLabelOpts = scale.options.pointLabels;
  const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;
  for (let i2 = 0; i2 < valueCount; i2++) {
    const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i2));
    padding[i2] = opts.padding;
    const pointPosition = scale.getPointPosition(i2, scale.drawingArea + padding[i2], additionalAngle);
    const plFont = toFont(opts.font);
    const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i2]);
    labelSizes[i2] = textSize;
    const angleRadians = _normalizeAngle(scale.getIndexAngle(i2) + additionalAngle);
    const angle = Math.round(toDegrees(angleRadians));
    const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
    const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
    updateLimits(limits, orig, angleRadians, hLimits, vLimits);
  }
  scale.setCenterPoint(orig.l - limits.l, limits.r - orig.r, orig.t - limits.t, limits.b - orig.b);
  scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);
}
function updateLimits(limits, orig, angle, hLimits, vLimits) {
  const sin = Math.abs(Math.sin(angle));
  const cos = Math.abs(Math.cos(angle));
  let x2 = 0;
  let y2 = 0;
  if (hLimits.start < orig.l) {
    x2 = (orig.l - hLimits.start) / sin;
    limits.l = Math.min(limits.l, orig.l - x2);
  } else if (hLimits.end > orig.r) {
    x2 = (hLimits.end - orig.r) / sin;
    limits.r = Math.max(limits.r, orig.r + x2);
  }
  if (vLimits.start < orig.t) {
    y2 = (orig.t - vLimits.start) / cos;
    limits.t = Math.min(limits.t, orig.t - y2);
  } else if (vLimits.end > orig.b) {
    y2 = (vLimits.end - orig.b) / cos;
    limits.b = Math.max(limits.b, orig.b + y2);
  }
}
function createPointLabelItem(scale, index, itemOpts) {
  const outerDistance = scale.drawingArea;
  const { extra, additionalAngle, padding, size } = itemOpts;
  const pointLabelPosition = scale.getPointPosition(index, outerDistance + extra + padding, additionalAngle);
  const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));
  const y2 = yForAngle(pointLabelPosition.y, size.h, angle);
  const textAlign = getTextAlignForAngle(angle);
  const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);
  return {
    visible: true,
    x: pointLabelPosition.x,
    y: y2,
    textAlign,
    left,
    top: y2,
    right: left + size.w,
    bottom: y2 + size.h
  };
}
function isNotOverlapped(item, area) {
  if (!area) {
    return true;
  }
  const { left, top, right, bottom } = item;
  const apexesInArea = _isPointInArea({
    x: left,
    y: top
  }, area) || _isPointInArea({
    x: left,
    y: bottom
  }, area) || _isPointInArea({
    x: right,
    y: top
  }, area) || _isPointInArea({
    x: right,
    y: bottom
  }, area);
  return !apexesInArea;
}
function buildPointLabelItems(scale, labelSizes, padding) {
  const items = [];
  const valueCount = scale._pointLabels.length;
  const opts = scale.options;
  const { centerPointLabels, display } = opts.pointLabels;
  const itemOpts = {
    extra: getTickBackdropHeight(opts) / 2,
    additionalAngle: centerPointLabels ? PI / valueCount : 0
  };
  let area;
  for (let i2 = 0; i2 < valueCount; i2++) {
    itemOpts.padding = padding[i2];
    itemOpts.size = labelSizes[i2];
    const item = createPointLabelItem(scale, i2, itemOpts);
    items.push(item);
    if (display === "auto") {
      item.visible = isNotOverlapped(item, area);
      if (item.visible) {
        area = item;
      }
    }
  }
  return items;
}
function getTextAlignForAngle(angle) {
  if (angle === 0 || angle === 180) {
    return "center";
  } else if (angle < 180) {
    return "left";
  }
  return "right";
}
function leftForTextAlign(x2, w2, align) {
  if (align === "right") {
    x2 -= w2;
  } else if (align === "center") {
    x2 -= w2 / 2;
  }
  return x2;
}
function yForAngle(y2, h3, angle) {
  if (angle === 90 || angle === 270) {
    y2 -= h3 / 2;
  } else if (angle > 270 || angle < 90) {
    y2 -= h3;
  }
  return y2;
}
function drawPointLabelBox(ctx, opts, item) {
  const { left, top, right, bottom } = item;
  const { backdropColor } = opts;
  if (!isNullOrUndef(backdropColor)) {
    const borderRadius = toTRBLCorners(opts.borderRadius);
    const padding = toPadding(opts.backdropPadding);
    ctx.fillStyle = backdropColor;
    const backdropLeft = left - padding.left;
    const backdropTop = top - padding.top;
    const backdropWidth = right - left + padding.width;
    const backdropHeight = bottom - top + padding.height;
    if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
      ctx.beginPath();
      addRoundedRectPath(ctx, {
        x: backdropLeft,
        y: backdropTop,
        w: backdropWidth,
        h: backdropHeight,
        radius: borderRadius
      });
      ctx.fill();
    } else {
      ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);
    }
  }
}
function drawPointLabels(scale, labelCount) {
  const { ctx, options: { pointLabels } } = scale;
  for (let i2 = labelCount - 1; i2 >= 0; i2--) {
    const item = scale._pointLabelItems[i2];
    if (!item.visible) {
      continue;
    }
    const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i2));
    drawPointLabelBox(ctx, optsAtIndex, item);
    const plFont = toFont(optsAtIndex.font);
    const { x: x2, y: y2, textAlign } = item;
    renderText(ctx, scale._pointLabels[i2], x2, y2 + plFont.lineHeight / 2, plFont, {
      color: optsAtIndex.color,
      textAlign,
      textBaseline: "middle"
    });
  }
}
function pathRadiusLine(scale, radius, circular, labelCount) {
  const { ctx } = scale;
  if (circular) {
    ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);
  } else {
    let pointPosition = scale.getPointPosition(0, radius);
    ctx.moveTo(pointPosition.x, pointPosition.y);
    for (let i2 = 1; i2 < labelCount; i2++) {
      pointPosition = scale.getPointPosition(i2, radius);
      ctx.lineTo(pointPosition.x, pointPosition.y);
    }
  }
}
function drawRadiusLine(scale, gridLineOpts, radius, labelCount, borderOpts) {
  const ctx = scale.ctx;
  const circular = gridLineOpts.circular;
  const { color: color2, lineWidth } = gridLineOpts;
  if (!circular && !labelCount || !color2 || !lineWidth || radius < 0) {
    return;
  }
  ctx.save();
  ctx.strokeStyle = color2;
  ctx.lineWidth = lineWidth;
  ctx.setLineDash(borderOpts.dash || []);
  ctx.lineDashOffset = borderOpts.dashOffset;
  ctx.beginPath();
  pathRadiusLine(scale, radius, circular, labelCount);
  ctx.closePath();
  ctx.stroke();
  ctx.restore();
}
function createPointLabelContext(parent, index, label) {
  return createContext(parent, {
    label,
    index,
    type: "pointLabel"
  });
}
var RadialLinearScale = class extends LinearScaleBase {
  constructor(cfg) {
    super(cfg);
    this.xCenter = void 0;
    this.yCenter = void 0;
    this.drawingArea = void 0;
    this._pointLabels = [];
    this._pointLabelItems = [];
  }
  setDimensions() {
    const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);
    const w2 = this.width = this.maxWidth - padding.width;
    const h3 = this.height = this.maxHeight - padding.height;
    this.xCenter = Math.floor(this.left + w2 / 2 + padding.left);
    this.yCenter = Math.floor(this.top + h3 / 2 + padding.top);
    this.drawingArea = Math.floor(Math.min(w2, h3) / 2);
  }
  determineDataLimits() {
    const { min, max } = this.getMinMax(false);
    this.min = isNumberFinite(min) && !isNaN(min) ? min : 0;
    this.max = isNumberFinite(max) && !isNaN(max) ? max : 0;
    this.handleTickRangeOptions();
  }
  computeTickLimit() {
    return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));
  }
  generateTickLabels(ticks) {
    LinearScaleBase.prototype.generateTickLabels.call(this, ticks);
    this._pointLabels = this.getLabels().map((value, index) => {
      const label = callback(this.options.pointLabels.callback, [
        value,
        index
      ], this);
      return label || label === 0 ? label : "";
    }).filter((v2, i2) => this.chart.getDataVisibility(i2));
  }
  fit() {
    const opts = this.options;
    if (opts.display && opts.pointLabels.display) {
      fitWithPointLabels(this);
    } else {
      this.setCenterPoint(0, 0, 0, 0);
    }
  }
  setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {
    this.xCenter += Math.floor((leftMovement - rightMovement) / 2);
    this.yCenter += Math.floor((topMovement - bottomMovement) / 2);
    this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));
  }
  getIndexAngle(index) {
    const angleMultiplier = TAU / (this._pointLabels.length || 1);
    const startAngle = this.options.startAngle || 0;
    return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));
  }
  getDistanceFromCenterForValue(value) {
    if (isNullOrUndef(value)) {
      return NaN;
    }
    const scalingFactor = this.drawingArea / (this.max - this.min);
    if (this.options.reverse) {
      return (this.max - value) * scalingFactor;
    }
    return (value - this.min) * scalingFactor;
  }
  getValueForDistanceFromCenter(distance) {
    if (isNullOrUndef(distance)) {
      return NaN;
    }
    const scaledDistance = distance / (this.drawingArea / (this.max - this.min));
    return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;
  }
  getPointLabelContext(index) {
    const pointLabels = this._pointLabels || [];
    if (index >= 0 && index < pointLabels.length) {
      const pointLabel = pointLabels[index];
      return createPointLabelContext(this.getContext(), index, pointLabel);
    }
  }
  getPointPosition(index, distanceFromCenter, additionalAngle = 0) {
    const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;
    return {
      x: Math.cos(angle) * distanceFromCenter + this.xCenter,
      y: Math.sin(angle) * distanceFromCenter + this.yCenter,
      angle
    };
  }
  getPointPositionForValue(index, value) {
    return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));
  }
  getBasePosition(index) {
    return this.getPointPositionForValue(index || 0, this.getBaseValue());
  }
  getPointLabelPosition(index) {
    const { left, top, right, bottom } = this._pointLabelItems[index];
    return {
      left,
      top,
      right,
      bottom
    };
  }
  drawBackground() {
    const { backgroundColor, grid: { circular } } = this.options;
    if (backgroundColor) {
      const ctx = this.ctx;
      ctx.save();
      ctx.beginPath();
      pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);
      ctx.closePath();
      ctx.fillStyle = backgroundColor;
      ctx.fill();
      ctx.restore();
    }
  }
  drawGrid() {
    const ctx = this.ctx;
    const opts = this.options;
    const { angleLines, grid, border } = opts;
    const labelCount = this._pointLabels.length;
    let i2, offset, position;
    if (opts.pointLabels.display) {
      drawPointLabels(this, labelCount);
    }
    if (grid.display) {
      this.ticks.forEach((tick, index) => {
        if (index !== 0 || index === 0 && this.min < 0) {
          offset = this.getDistanceFromCenterForValue(tick.value);
          const context = this.getContext(index);
          const optsAtIndex = grid.setContext(context);
          const optsAtIndexBorder = border.setContext(context);
          drawRadiusLine(this, optsAtIndex, offset, labelCount, optsAtIndexBorder);
        }
      });
    }
    if (angleLines.display) {
      ctx.save();
      for (i2 = labelCount - 1; i2 >= 0; i2--) {
        const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i2));
        const { color: color2, lineWidth } = optsAtIndex;
        if (!lineWidth || !color2) {
          continue;
        }
        ctx.lineWidth = lineWidth;
        ctx.strokeStyle = color2;
        ctx.setLineDash(optsAtIndex.borderDash);
        ctx.lineDashOffset = optsAtIndex.borderDashOffset;
        offset = this.getDistanceFromCenterForValue(opts.reverse ? this.min : this.max);
        position = this.getPointPosition(i2, offset);
        ctx.beginPath();
        ctx.moveTo(this.xCenter, this.yCenter);
        ctx.lineTo(position.x, position.y);
        ctx.stroke();
      }
      ctx.restore();
    }
  }
  drawBorder() {
  }
  drawLabels() {
    const ctx = this.ctx;
    const opts = this.options;
    const tickOpts = opts.ticks;
    if (!tickOpts.display) {
      return;
    }
    const startAngle = this.getIndexAngle(0);
    let offset, width;
    ctx.save();
    ctx.translate(this.xCenter, this.yCenter);
    ctx.rotate(startAngle);
    ctx.textAlign = "center";
    ctx.textBaseline = "middle";
    this.ticks.forEach((tick, index) => {
      if (index === 0 && this.min >= 0 && !opts.reverse) {
        return;
      }
      const optsAtIndex = tickOpts.setContext(this.getContext(index));
      const tickFont = toFont(optsAtIndex.font);
      offset = this.getDistanceFromCenterForValue(this.ticks[index].value);
      if (optsAtIndex.showLabelBackdrop) {
        ctx.font = tickFont.string;
        width = ctx.measureText(tick.label).width;
        ctx.fillStyle = optsAtIndex.backdropColor;
        const padding = toPadding(optsAtIndex.backdropPadding);
        ctx.fillRect(-width / 2 - padding.left, -offset - tickFont.size / 2 - padding.top, width + padding.width, tickFont.size + padding.height);
      }
      renderText(ctx, tick.label, 0, -offset, tickFont, {
        color: optsAtIndex.color,
        strokeColor: optsAtIndex.textStrokeColor,
        strokeWidth: optsAtIndex.textStrokeWidth
      });
    });
    ctx.restore();
  }
  drawTitle() {
  }
};
__publicField(RadialLinearScale, "id", "radialLinear");
__publicField(RadialLinearScale, "defaults", {
  display: true,
  animate: true,
  position: "chartArea",
  angleLines: {
    display: true,
    lineWidth: 1,
    borderDash: [],
    borderDashOffset: 0
  },
  grid: {
    circular: false
  },
  startAngle: 0,
  ticks: {
    showLabelBackdrop: true,
    callback: Ticks.formatters.numeric
  },
  pointLabels: {
    backdropColor: void 0,
    backdropPadding: 2,
    display: true,
    font: {
      size: 10
    },
    callback(label) {
      return label;
    },
    padding: 5,
    centerPointLabels: false
  }
});
__publicField(RadialLinearScale, "defaultRoutes", {
  "angleLines.color": "borderColor",
  "pointLabels.color": "color",
  "ticks.color": "color"
});
__publicField(RadialLinearScale, "descriptors", {
  angleLines: {
    _fallback: "grid"
  }
});
var INTERVALS = {
  millisecond: {
    common: true,
    size: 1,
    steps: 1e3
  },
  second: {
    common: true,
    size: 1e3,
    steps: 60
  },
  minute: {
    common: true,
    size: 6e4,
    steps: 60
  },
  hour: {
    common: true,
    size: 36e5,
    steps: 24
  },
  day: {
    common: true,
    size: 864e5,
    steps: 30
  },
  week: {
    common: false,
    size: 6048e5,
    steps: 4
  },
  month: {
    common: true,
    size: 2628e6,
    steps: 12
  },
  quarter: {
    common: false,
    size: 7884e6,
    steps: 4
  },
  year: {
    common: true,
    size: 3154e7
  }
};
var UNITS = /* @__PURE__ */ Object.keys(INTERVALS);
function sorter(a2, b2) {
  return a2 - b2;
}
function parse2(scale, input) {
  if (isNullOrUndef(input)) {
    return null;
  }
  const adapter = scale._adapter;
  const { parser, round: round2, isoWeekday } = scale._parseOpts;
  let value = input;
  if (typeof parser === "function") {
    value = parser(value);
  }
  if (!isNumberFinite(value)) {
    value = typeof parser === "string" ? adapter.parse(value, parser) : adapter.parse(value);
  }
  if (value === null) {
    return null;
  }
  if (round2) {
    value = round2 === "week" && (isNumber(isoWeekday) || isoWeekday === true) ? adapter.startOf(value, "isoWeek", isoWeekday) : adapter.startOf(value, round2);
  }
  return +value;
}
function determineUnitForAutoTicks(minUnit, min, max, capacity) {
  const ilen = UNITS.length;
  for (let i2 = UNITS.indexOf(minUnit); i2 < ilen - 1; ++i2) {
    const interval = INTERVALS[UNITS[i2]];
    const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;
    if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
      return UNITS[i2];
    }
  }
  return UNITS[ilen - 1];
}
function determineUnitForFormatting(scale, numTicks, minUnit, min, max) {
  for (let i2 = UNITS.length - 1; i2 >= UNITS.indexOf(minUnit); i2--) {
    const unit = UNITS[i2];
    if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {
      return unit;
    }
  }
  return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];
}
function determineMajorUnit(unit) {
  for (let i2 = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i2 < ilen; ++i2) {
    if (INTERVALS[UNITS[i2]].common) {
      return UNITS[i2];
    }
  }
}
function addTick(ticks, time, timestamps) {
  if (!timestamps) {
    ticks[time] = true;
  } else if (timestamps.length) {
    const { lo, hi: hi2 } = _lookup(timestamps, time);
    const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi2];
    ticks[timestamp] = true;
  }
}
function setMajorTicks(scale, ticks, map3, majorUnit) {
  const adapter = scale._adapter;
  const first = +adapter.startOf(ticks[0].value, majorUnit);
  const last = ticks[ticks.length - 1].value;
  let major, index;
  for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) {
    index = map3[major];
    if (index >= 0) {
      ticks[index].major = true;
    }
  }
  return ticks;
}
function ticksFromTimestamps(scale, values, majorUnit) {
  const ticks = [];
  const map3 = {};
  const ilen = values.length;
  let i2, value;
  for (i2 = 0; i2 < ilen; ++i2) {
    value = values[i2];
    map3[value] = i2;
    ticks.push({
      value,
      major: false
    });
  }
  return ilen === 0 || !majorUnit ? ticks : setMajorTicks(scale, ticks, map3, majorUnit);
}
var TimeScale = class extends Scale {
  constructor(props) {
    super(props);
    this._cache = {
      data: [],
      labels: [],
      all: []
    };
    this._unit = "day";
    this._majorUnit = void 0;
    this._offsets = {};
    this._normalized = false;
    this._parseOpts = void 0;
  }
  init(scaleOpts, opts = {}) {
    const time = scaleOpts.time || (scaleOpts.time = {});
    const adapter = this._adapter = new adapters._date(scaleOpts.adapters.date);
    adapter.init(opts);
    mergeIf(time.displayFormats, adapter.formats());
    this._parseOpts = {
      parser: time.parser,
      round: time.round,
      isoWeekday: time.isoWeekday
    };
    super.init(scaleOpts);
    this._normalized = opts.normalized;
  }
  parse(raw, index) {
    if (raw === void 0) {
      return null;
    }
    return parse2(this, raw);
  }
  beforeLayout() {
    super.beforeLayout();
    this._cache = {
      data: [],
      labels: [],
      all: []
    };
  }
  determineDataLimits() {
    const options = this.options;
    const adapter = this._adapter;
    const unit = options.time.unit || "day";
    let { min, max, minDefined, maxDefined } = this.getUserBounds();
    function _applyBounds(bounds) {
      if (!minDefined && !isNaN(bounds.min)) {
        min = Math.min(min, bounds.min);
      }
      if (!maxDefined && !isNaN(bounds.max)) {
        max = Math.max(max, bounds.max);
      }
    }
    if (!minDefined || !maxDefined) {
      _applyBounds(this._getLabelBounds());
      if (options.bounds !== "ticks" || options.ticks.source !== "labels") {
        _applyBounds(this.getMinMax(false));
      }
    }
    min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);
    max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;
    this.min = Math.min(min, max - 1);
    this.max = Math.max(min + 1, max);
  }
  _getLabelBounds() {
    const arr = this.getLabelTimestamps();
    let min = Number.POSITIVE_INFINITY;
    let max = Number.NEGATIVE_INFINITY;
    if (arr.length) {
      min = arr[0];
      max = arr[arr.length - 1];
    }
    return {
      min,
      max
    };
  }
  buildTicks() {
    const options = this.options;
    const timeOpts = options.time;
    const tickOpts = options.ticks;
    const timestamps = tickOpts.source === "labels" ? this.getLabelTimestamps() : this._generate();
    if (options.bounds === "ticks" && timestamps.length) {
      this.min = this._userMin || timestamps[0];
      this.max = this._userMax || timestamps[timestamps.length - 1];
    }
    const min = this.min;
    const max = this.max;
    const ticks = _filterBetween(timestamps, min, max);
    this._unit = timeOpts.unit || (tickOpts.autoSkip ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min)) : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));
    this._majorUnit = !tickOpts.major.enabled || this._unit === "year" ? void 0 : determineMajorUnit(this._unit);
    this.initOffsets(timestamps);
    if (options.reverse) {
      ticks.reverse();
    }
    return ticksFromTimestamps(this, ticks, this._majorUnit);
  }
  afterAutoSkip() {
    if (this.options.offsetAfterAutoskip) {
      this.initOffsets(this.ticks.map((tick) => +tick.value));
    }
  }
  initOffsets(timestamps = []) {
    let start = 0;
    let end = 0;
    let first, last;
    if (this.options.offset && timestamps.length) {
      first = this.getDecimalForValue(timestamps[0]);
      if (timestamps.length === 1) {
        start = 1 - first;
      } else {
        start = (this.getDecimalForValue(timestamps[1]) - first) / 2;
      }
      last = this.getDecimalForValue(timestamps[timestamps.length - 1]);
      if (timestamps.length === 1) {
        end = last;
      } else {
        end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;
      }
    }
    const limit = timestamps.length < 3 ? 0.5 : 0.25;
    start = _limitValue(start, 0, limit);
    end = _limitValue(end, 0, limit);
    this._offsets = {
      start,
      end,
      factor: 1 / (start + 1 + end)
    };
  }
  _generate() {
    const adapter = this._adapter;
    const min = this.min;
    const max = this.max;
    const options = this.options;
    const timeOpts = options.time;
    const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));
    const stepSize = valueOrDefault(options.ticks.stepSize, 1);
    const weekday = minor === "week" ? timeOpts.isoWeekday : false;
    const hasWeekday = isNumber(weekday) || weekday === true;
    const ticks = {};
    let first = min;
    let time, count;
    if (hasWeekday) {
      first = +adapter.startOf(first, "isoWeek", weekday);
    }
    first = +adapter.startOf(first, hasWeekday ? "day" : minor);
    if (adapter.diff(max, min, minor) > 1e5 * stepSize) {
      throw new Error(min + " and " + max + " are too far apart with stepSize of " + stepSize + " " + minor);
    }
    const timestamps = options.ticks.source === "data" && this.getDataTimestamps();
    for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) {
      addTick(ticks, time, timestamps);
    }
    if (time === max || options.bounds === "ticks" || count === 1) {
      addTick(ticks, time, timestamps);
    }
    return Object.keys(ticks).sort(sorter).map((x2) => +x2);
  }
  getLabelForValue(value) {
    const adapter = this._adapter;
    const timeOpts = this.options.time;
    if (timeOpts.tooltipFormat) {
      return adapter.format(value, timeOpts.tooltipFormat);
    }
    return adapter.format(value, timeOpts.displayFormats.datetime);
  }
  format(value, format) {
    const options = this.options;
    const formats = options.time.displayFormats;
    const unit = this._unit;
    const fmt = format || formats[unit];
    return this._adapter.format(value, fmt);
  }
  _tickFormatFunction(time, index, ticks, format) {
    const options = this.options;
    const formatter = options.ticks.callback;
    if (formatter) {
      return callback(formatter, [
        time,
        index,
        ticks
      ], this);
    }
    const formats = options.time.displayFormats;
    const unit = this._unit;
    const majorUnit = this._majorUnit;
    const minorFormat = unit && formats[unit];
    const majorFormat = majorUnit && formats[majorUnit];
    const tick = ticks[index];
    const major = majorUnit && majorFormat && tick && tick.major;
    return this._adapter.format(time, format || (major ? majorFormat : minorFormat));
  }
  generateTickLabels(ticks) {
    let i2, ilen, tick;
    for (i2 = 0, ilen = ticks.length; i2 < ilen; ++i2) {
      tick = ticks[i2];
      tick.label = this._tickFormatFunction(tick.value, i2, ticks);
    }
  }
  getDecimalForValue(value) {
    return value === null ? NaN : (value - this.min) / (this.max - this.min);
  }
  getPixelForValue(value) {
    const offsets = this._offsets;
    const pos = this.getDecimalForValue(value);
    return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);
  }
  getValueForPixel(pixel) {
    const offsets = this._offsets;
    const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
    return this.min + pos * (this.max - this.min);
  }
  _getLabelSize(label) {
    const ticksOpts = this.options.ticks;
    const tickLabelWidth = this.ctx.measureText(label).width;
    const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);
    const cosRotation = Math.cos(angle);
    const sinRotation = Math.sin(angle);
    const tickFontSize = this._resolveTickFontOptions(0).size;
    return {
      w: tickLabelWidth * cosRotation + tickFontSize * sinRotation,
      h: tickLabelWidth * sinRotation + tickFontSize * cosRotation
    };
  }
  _getLabelCapacity(exampleTime) {
    const timeOpts = this.options.time;
    const displayFormats = timeOpts.displayFormats;
    const format = displayFormats[timeOpts.unit] || displayFormats.millisecond;
    const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [
      exampleTime
    ], this._majorUnit), format);
    const size = this._getLabelSize(exampleLabel);
    const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;
    return capacity > 0 ? capacity : 1;
  }
  getDataTimestamps() {
    let timestamps = this._cache.data || [];
    let i2, ilen;
    if (timestamps.length) {
      return timestamps;
    }
    const metas = this.getMatchingVisibleMetas();
    if (this._normalized && metas.length) {
      return this._cache.data = metas[0].controller.getAllParsedValues(this);
    }
    for (i2 = 0, ilen = metas.length; i2 < ilen; ++i2) {
      timestamps = timestamps.concat(metas[i2].controller.getAllParsedValues(this));
    }
    return this._cache.data = this.normalize(timestamps);
  }
  getLabelTimestamps() {
    const timestamps = this._cache.labels || [];
    let i2, ilen;
    if (timestamps.length) {
      return timestamps;
    }
    const labels = this.getLabels();
    for (i2 = 0, ilen = labels.length; i2 < ilen; ++i2) {
      timestamps.push(parse2(this, labels[i2]));
    }
    return this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps);
  }
  normalize(values) {
    return _arrayUnique(values.sort(sorter));
  }
};
__publicField(TimeScale, "id", "time");
__publicField(TimeScale, "defaults", {
  bounds: "data",
  adapters: {},
  time: {
    parser: false,
    unit: false,
    round: false,
    isoWeekday: false,
    minUnit: "millisecond",
    displayFormats: {}
  },
  ticks: {
    source: "auto",
    callback: false,
    major: {
      enabled: false
    }
  }
});
function interpolate2(table, val, reverse) {
  let lo = 0;
  let hi2 = table.length - 1;
  let prevSource, nextSource, prevTarget, nextTarget;
  if (reverse) {
    if (val >= table[lo].pos && val <= table[hi2].pos) {
      ({ lo, hi: hi2 } = _lookupByKey(table, "pos", val));
    }
    ({ pos: prevSource, time: prevTarget } = table[lo]);
    ({ pos: nextSource, time: nextTarget } = table[hi2]);
  } else {
    if (val >= table[lo].time && val <= table[hi2].time) {
      ({ lo, hi: hi2 } = _lookupByKey(table, "time", val));
    }
    ({ time: prevSource, pos: prevTarget } = table[lo]);
    ({ time: nextSource, pos: nextTarget } = table[hi2]);
  }
  const span = nextSource - prevSource;
  return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;
}
var TimeSeriesScale = class extends TimeScale {
  constructor(props) {
    super(props);
    this._table = [];
    this._minPos = void 0;
    this._tableRange = void 0;
  }
  initOffsets() {
    const timestamps = this._getTimestampsForTable();
    const table = this._table = this.buildLookupTable(timestamps);
    this._minPos = interpolate2(table, this.min);
    this._tableRange = interpolate2(table, this.max) - this._minPos;
    super.initOffsets(timestamps);
  }
  buildLookupTable(timestamps) {
    const { min, max } = this;
    const items = [];
    const table = [];
    let i2, ilen, prev, curr, next;
    for (i2 = 0, ilen = timestamps.length; i2 < ilen; ++i2) {
      curr = timestamps[i2];
      if (curr >= min && curr <= max) {
        items.push(curr);
      }
    }
    if (items.length < 2) {
      return [
        {
          time: min,
          pos: 0
        },
        {
          time: max,
          pos: 1
        }
      ];
    }
    for (i2 = 0, ilen = items.length; i2 < ilen; ++i2) {
      next = items[i2 + 1];
      prev = items[i2 - 1];
      curr = items[i2];
      if (Math.round((next + prev) / 2) !== curr) {
        table.push({
          time: curr,
          pos: i2 / (ilen - 1)
        });
      }
    }
    return table;
  }
  _generate() {
    const min = this.min;
    const max = this.max;
    let timestamps = super.getDataTimestamps();
    if (!timestamps.includes(min) || !timestamps.length) {
      timestamps.splice(0, 0, min);
    }
    if (!timestamps.includes(max) || timestamps.length === 1) {
      timestamps.push(max);
    }
    return timestamps.sort((a2, b2) => a2 - b2);
  }
  _getTimestampsForTable() {
    let timestamps = this._cache.all || [];
    if (timestamps.length) {
      return timestamps;
    }
    const data = this.getDataTimestamps();
    const label = this.getLabelTimestamps();
    if (data.length && label.length) {
      timestamps = this.normalize(data.concat(label));
    } else {
      timestamps = data.length ? data : label;
    }
    timestamps = this._cache.all = timestamps;
    return timestamps;
  }
  getDecimalForValue(value) {
    return (interpolate2(this._table, value) - this._minPos) / this._tableRange;
  }
  getValueForPixel(pixel) {
    const offsets = this._offsets;
    const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
    return interpolate2(this._table, decimal * this._tableRange + this._minPos, true);
  }
};
__publicField(TimeSeriesScale, "id", "timeseries");
__publicField(TimeSeriesScale, "defaults", TimeScale.defaults);

// src/ui/obsidian-ui-components/content-container/settings-page/statistics-page/statistics-page.tsx
var import_obsidian26 = require("obsidian");

// src/scheduling/algorithms/base/sr-algorithm.ts
var SRAlgorithm = class _SRAlgorithm {
  static getInstance() {
    if (!_SRAlgorithm.instance) {
      throw new Error("there is no SrsAlgorithm instance.");
    }
    return _SRAlgorithm.instance;
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/statistics-page/settings-item-override-component.tsx
var import_obsidian25 = require("obsidian");
var SettingsItemOverrideComponent = class extends import_obsidian25.BaseComponent {
  constructor(parentContainerEl) {
    super();
    parentContainerEl.addClass("sr-setting-override");
    this.containerEl = parentContainerEl.createDiv();
  }
  /**
   * Destroys the component.
   */
  destroy() {
    this.containerEl.empty();
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/statistics-page/chart-component.tsx
var ChartComponent = class extends SettingsItemOverrideComponent {
  constructor(parentContainerEl, canvasId, summaryId, type, title, subtitle, labels, data, summary, seriesTitle = "", xAxisTitle = "", yAxisTitle = "") {
    super(parentContainerEl);
    this.containerEl.addClass("sr-chart-container");
    this.canvasContainerEl = this.containerEl.createDiv();
    this.canvasContainerEl.addClass("sr-chart-canvas-container");
    this.canvasEl = this.canvasContainerEl.createEl("canvas");
    this.canvasEl.id = canvasId;
    this.summaryEl = this.containerEl.createDiv();
    this.summaryEl.id = summaryId;
    const style = getComputedStyle(activeDocument.body);
    const textColor = style.getPropertyValue("--text-normal");
    let scales = {};
    let backgroundColor = ["#2196f3"];
    if (type !== "pie") {
      scales = {
        x: {
          title: {
            display: xAxisTitle !== "",
            text: xAxisTitle,
            color: textColor
          }
        },
        y: {
          title: {
            display: yAxisTitle !== "",
            text: yAxisTitle,
            color: textColor
          }
        }
      };
    } else {
      backgroundColor = ["#2196f3", "#4caf50", "green"];
    }
    const shouldFilter = canvasId === "forecastChart" || canvasId === "intervalsChart";
    const statsChart = new Chart(activeDocument.getElementById(canvasId), {
      type,
      data: {
        labels: shouldFilter ? labels.slice(0, 31) : labels,
        datasets: [
          {
            label: seriesTitle,
            backgroundColor,
            data: shouldFilter ? data.slice(0, 31) : data,
            borderRadius: 4
          }
        ]
      },
      options: {
        scales,
        plugins: {
          title: {
            display: title !== "",
            text: title,
            font: {
              size: 22
            },
            color: textColor
          },
          subtitle: {
            display: subtitle !== "",
            text: subtitle,
            font: {
              size: 16,
              style: "italic"
            },
            color: textColor,
            padding: { top: 0, bottom: 24 }
          },
          legend: {
            display: false
          }
        },
        aspectRatio: 2,
        responsive: true,
        animation: {
          duration: 0
        }
      }
    });
    if (shouldFilter) {
      const chartPeriodEl = activeDocument.getElementById(
        "sr-chart-period"
      );
      chartPeriodEl.addEventListener("change", () => {
        let filteredLabels, filteredData;
        const chartPeriod = chartPeriodEl.value;
        if (chartPeriod === "month") {
          filteredLabels = labels.slice(0, 31);
          filteredData = data.slice(0, 31);
        } else if (chartPeriod === "quarter") {
          filteredLabels = labels.slice(0, 91);
          filteredData = data.slice(0, 91);
        } else if (chartPeriod === "year") {
          filteredLabels = labels.slice(0, 366);
          filteredData = data.slice(0, 366);
        } else {
          filteredLabels = labels;
          filteredData = data;
        }
        statsChart.data.labels = filteredLabels;
        statsChart.data.datasets[0] = {
          ...statsChart.data.datasets[0],
          label: seriesTitle,
          backgroundColor,
          data: filteredData
        };
        statsChart.update();
      });
    }
    const canvasSummary = activeDocument.getElementById(
      `${canvasId}Summary`
    );
    if (canvasSummary) {
      canvasSummary.setText(summary);
      canvasSummary.setCssProps({
        "text-align": canvasId === "cardTypesChart" ? "right" : "center"
      });
    }
    this.chart = statsChart;
  }
  destroy() {
    if (this.chart) this.chart.destroy();
    this.containerEl.empty();
  }
};

// node_modules/.pnpm/gridjs@6.2.0/node_modules/gridjs/dist/gridjs.module.js
function t2(t3, n2) {
  for (var e2 = 0; e2 < n2.length; e2++) {
    var r2 = n2[e2];
    r2.enumerable = r2.enumerable || false, r2.configurable = true, "value" in r2 && (r2.writable = true), Object.defineProperty(t3, "symbol" == typeof (o2 = (function(t4, n3) {
      if ("object" != typeof t4 || null === t4) return t4;
      var e3 = t4[Symbol.toPrimitive];
      if (void 0 !== e3) {
        var r3 = e3.call(t4, "string");
        if ("object" != typeof r3) return r3;
        throw new TypeError("@@toPrimitive must return a primitive value.");
      }
      return String(t4);
    })(r2.key)) ? o2 : String(o2), r2);
  }
  var o2;
}
function n(n2, e2, r2) {
  return e2 && t2(n2.prototype, e2), r2 && t2(n2, r2), Object.defineProperty(n2, "prototype", { writable: false }), n2;
}
function e() {
  return e = Object.assign ? Object.assign.bind() : function(t3) {
    for (var n2 = 1; n2 < arguments.length; n2++) {
      var e2 = arguments[n2];
      for (var r2 in e2) Object.prototype.hasOwnProperty.call(e2, r2) && (t3[r2] = e2[r2]);
    }
    return t3;
  }, e.apply(this, arguments);
}
function r(t3, n2) {
  t3.prototype = Object.create(n2.prototype), t3.prototype.constructor = t3, o(t3, n2);
}
function o(t3, n2) {
  return o = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t4, n3) {
    return t4.__proto__ = n3, t4;
  }, o(t3, n2);
}
function i(t3) {
  if (void 0 === t3) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  return t3;
}
function u(t3, n2) {
  (null == n2 || n2 > t3.length) && (n2 = t3.length);
  for (var e2 = 0, r2 = new Array(n2); e2 < n2; e2++) r2[e2] = t3[e2];
  return r2;
}
function s(t3, n2) {
  var e2 = "undefined" != typeof Symbol && t3[Symbol.iterator] || t3["@@iterator"];
  if (e2) return (e2 = e2.call(t3)).next.bind(e2);
  if (Array.isArray(t3) || (e2 = (function(t4, n3) {
    if (t4) {
      if ("string" == typeof t4) return u(t4, n3);
      var e3 = Object.prototype.toString.call(t4).slice(8, -1);
      return "Object" === e3 && t4.constructor && (e3 = t4.constructor.name), "Map" === e3 || "Set" === e3 ? Array.from(t4) : "Arguments" === e3 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e3) ? u(t4, n3) : void 0;
    }
  })(t3)) || n2 && t3 && "number" == typeof t3.length) {
    e2 && (t3 = e2);
    var r2 = 0;
    return function() {
      return r2 >= t3.length ? { done: true } : { done: false, value: t3[r2++] };
    };
  }
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var a;
!(function(t3) {
  t3[t3.Init = 0] = "Init", t3[t3.Loading = 1] = "Loading", t3[t3.Loaded = 2] = "Loaded", t3[t3.Rendered = 3] = "Rendered", t3[t3.Error = 4] = "Error";
})(a || (a = {}));
var l;
var c;
var f;
var p;
var d;
var h;
var _;
var m = {};
var v = [];
var y = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
function g(t3, n2) {
  for (var e2 in n2) t3[e2] = n2[e2];
  return t3;
}
function b(t3) {
  var n2 = t3.parentNode;
  n2 && n2.removeChild(t3);
}
function w(t3, n2, e2) {
  var r2, o2, i2, u2 = {};
  for (i2 in n2) "key" == i2 ? r2 = n2[i2] : "ref" == i2 ? o2 = n2[i2] : u2[i2] = n2[i2];
  if (arguments.length > 2 && (u2.children = arguments.length > 3 ? l.call(arguments, 2) : e2), "function" == typeof t3 && null != t3.defaultProps) for (i2 in t3.defaultProps) void 0 === u2[i2] && (u2[i2] = t3.defaultProps[i2]);
  return x(t3, u2, r2, o2, null);
}
function x(t3, n2, e2, r2, o2) {
  var i2 = { type: t3, props: n2, key: e2, ref: r2, __k: null, __: null, __b: 0, __e: null, __d: void 0, __c: null, __h: null, constructor: void 0, __v: null == o2 ? ++f : o2 };
  return null == o2 && null != c.vnode && c.vnode(i2), i2;
}
function S(t3) {
  return t3.children;
}
function N(t3, n2) {
  this.props = t3, this.context = n2;
}
function P(t3, n2) {
  if (null == n2) return t3.__ ? P(t3.__, t3.__.__k.indexOf(t3) + 1) : null;
  for (var e2; n2 < t3.__k.length; n2++) if (null != (e2 = t3.__k[n2]) && null != e2.__e) return e2.__e;
  return "function" == typeof t3.type ? P(t3) : null;
}
function C(t3) {
  var n2, e2;
  if (null != (t3 = t3.__) && null != t3.__c) {
    for (t3.__e = t3.__c.base = null, n2 = 0; n2 < t3.__k.length; n2++) if (null != (e2 = t3.__k[n2]) && null != e2.__e) {
      t3.__e = t3.__c.base = e2.__e;
      break;
    }
    return C(t3);
  }
}
function E(t3) {
  (!t3.__d && (t3.__d = true) && d.push(t3) && !I.__r++ || h !== c.debounceRendering) && ((h = c.debounceRendering) || setTimeout)(I);
}
function I() {
  for (var t3; I.__r = d.length; ) t3 = d.sort(function(t4, n2) {
    return t4.__v.__b - n2.__v.__b;
  }), d = [], t3.some(function(t4) {
    var n2, e2, r2, o2, i2, u2;
    t4.__d && (i2 = (o2 = (n2 = t4).__v).__e, (u2 = n2.__P) && (e2 = [], (r2 = g({}, o2)).__v = o2.__v + 1, M(u2, o2, r2, n2.__n, void 0 !== u2.ownerSVGElement, null != o2.__h ? [i2] : null, e2, null == i2 ? P(o2) : i2, o2.__h), F(e2, o2), o2.__e != i2 && C(o2)));
  });
}
function T(t3, n2, e2, r2, o2, i2, u2, s2, a2, l2) {
  var c2, f2, p2, d2, h3, _2, y2, g2 = r2 && r2.__k || v, b2 = g2.length;
  for (e2.__k = [], c2 = 0; c2 < n2.length; c2++) if (null != (d2 = e2.__k[c2] = null == (d2 = n2[c2]) || "boolean" == typeof d2 ? null : "string" == typeof d2 || "number" == typeof d2 || "bigint" == typeof d2 ? x(null, d2, null, null, d2) : Array.isArray(d2) ? x(S, { children: d2 }, null, null, null) : d2.__b > 0 ? x(d2.type, d2.props, d2.key, d2.ref ? d2.ref : null, d2.__v) : d2)) {
    if (d2.__ = e2, d2.__b = e2.__b + 1, null === (p2 = g2[c2]) || p2 && d2.key == p2.key && d2.type === p2.type) g2[c2] = void 0;
    else for (f2 = 0; f2 < b2; f2++) {
      if ((p2 = g2[f2]) && d2.key == p2.key && d2.type === p2.type) {
        g2[f2] = void 0;
        break;
      }
      p2 = null;
    }
    M(t3, d2, p2 = p2 || m, o2, i2, u2, s2, a2, l2), h3 = d2.__e, (f2 = d2.ref) && p2.ref != f2 && (y2 || (y2 = []), p2.ref && y2.push(p2.ref, null, d2), y2.push(f2, d2.__c || h3, d2)), null != h3 ? (null == _2 && (_2 = h3), "function" == typeof d2.type && d2.__k === p2.__k ? d2.__d = a2 = L(d2, a2, t3) : a2 = A(t3, d2, p2, g2, h3, a2), "function" == typeof e2.type && (e2.__d = a2)) : a2 && p2.__e == a2 && a2.parentNode != t3 && (a2 = P(p2));
  }
  for (e2.__e = _2, c2 = b2; c2--; ) null != g2[c2] && W(g2[c2], g2[c2]);
  if (y2) for (c2 = 0; c2 < y2.length; c2++) U(y2[c2], y2[++c2], y2[++c2]);
}
function L(t3, n2, e2) {
  for (var r2, o2 = t3.__k, i2 = 0; o2 && i2 < o2.length; i2++) (r2 = o2[i2]) && (r2.__ = t3, n2 = "function" == typeof r2.type ? L(r2, n2, e2) : A(e2, r2, r2, o2, r2.__e, n2));
  return n2;
}
function A(t3, n2, e2, r2, o2, i2) {
  var u2, s2, a2;
  if (void 0 !== n2.__d) u2 = n2.__d, n2.__d = void 0;
  else if (null == e2 || o2 != i2 || null == o2.parentNode) t: if (null == i2 || i2.parentNode !== t3) t3.appendChild(o2), u2 = null;
  else {
    for (s2 = i2, a2 = 0; (s2 = s2.nextSibling) && a2 < r2.length; a2 += 1) if (s2 == o2) break t;
    t3.insertBefore(o2, i2), u2 = i2;
  }
  return void 0 !== u2 ? u2 : o2.nextSibling;
}
function O(t3, n2, e2) {
  "-" === n2[0] ? t3.setProperty(n2, e2) : t3[n2] = null == e2 ? "" : "number" != typeof e2 || y.test(n2) ? e2 : e2 + "px";
}
function H(t3, n2, e2, r2, o2) {
  var i2;
  t: if ("style" === n2) if ("string" == typeof e2) t3.style.cssText = e2;
  else {
    if ("string" == typeof r2 && (t3.style.cssText = r2 = ""), r2) for (n2 in r2) e2 && n2 in e2 || O(t3.style, n2, "");
    if (e2) for (n2 in e2) r2 && e2[n2] === r2[n2] || O(t3.style, n2, e2[n2]);
  }
  else if ("o" === n2[0] && "n" === n2[1]) i2 = n2 !== (n2 = n2.replace(/Capture$/, "")), n2 = n2.toLowerCase() in t3 ? n2.toLowerCase().slice(2) : n2.slice(2), t3.l || (t3.l = {}), t3.l[n2 + i2] = e2, e2 ? r2 || t3.addEventListener(n2, i2 ? D : j, i2) : t3.removeEventListener(n2, i2 ? D : j, i2);
  else if ("dangerouslySetInnerHTML" !== n2) {
    if (o2) n2 = n2.replace(/xlink(H|:h)/, "h").replace(/sName$/, "s");
    else if ("href" !== n2 && "list" !== n2 && "form" !== n2 && "tabIndex" !== n2 && "download" !== n2 && n2 in t3) try {
      t3[n2] = null == e2 ? "" : e2;
      break t;
    } catch (t4) {
    }
    "function" == typeof e2 || (null == e2 || false === e2 && -1 == n2.indexOf("-") ? t3.removeAttribute(n2) : t3.setAttribute(n2, e2));
  }
}
function j(t3) {
  this.l[t3.type + false](c.event ? c.event(t3) : t3);
}
function D(t3) {
  this.l[t3.type + true](c.event ? c.event(t3) : t3);
}
function M(t3, n2, e2, r2, o2, i2, u2, s2, a2) {
  var l2, f2, p2, d2, h3, _2, m2, v2, y2, b2, w2, x2, k, P2, C2, E2 = n2.type;
  if (void 0 !== n2.constructor) return null;
  null != e2.__h && (a2 = e2.__h, s2 = n2.__e = e2.__e, n2.__h = null, i2 = [s2]), (l2 = c.__b) && l2(n2);
  try {
    t: if ("function" == typeof E2) {
      if (v2 = n2.props, y2 = (l2 = E2.contextType) && r2[l2.__c], b2 = l2 ? y2 ? y2.props.value : l2.__ : r2, e2.__c ? m2 = (f2 = n2.__c = e2.__c).__ = f2.__E : ("prototype" in E2 && E2.prototype.render ? n2.__c = f2 = new E2(v2, b2) : (n2.__c = f2 = new N(v2, b2), f2.constructor = E2, f2.render = B), y2 && y2.sub(f2), f2.props = v2, f2.state || (f2.state = {}), f2.context = b2, f2.__n = r2, p2 = f2.__d = true, f2.__h = [], f2._sb = []), null == f2.__s && (f2.__s = f2.state), null != E2.getDerivedStateFromProps && (f2.__s == f2.state && (f2.__s = g({}, f2.__s)), g(f2.__s, E2.getDerivedStateFromProps(v2, f2.__s))), d2 = f2.props, h3 = f2.state, p2) null == E2.getDerivedStateFromProps && null != f2.componentWillMount && f2.componentWillMount(), null != f2.componentDidMount && f2.__h.push(f2.componentDidMount);
      else {
        if (null == E2.getDerivedStateFromProps && v2 !== d2 && null != f2.componentWillReceiveProps && f2.componentWillReceiveProps(v2, b2), !f2.__e && null != f2.shouldComponentUpdate && false === f2.shouldComponentUpdate(v2, f2.__s, b2) || n2.__v === e2.__v) {
          for (f2.props = v2, f2.state = f2.__s, n2.__v !== e2.__v && (f2.__d = false), f2.__v = n2, n2.__e = e2.__e, n2.__k = e2.__k, n2.__k.forEach(function(t4) {
            t4 && (t4.__ = n2);
          }), w2 = 0; w2 < f2._sb.length; w2++) f2.__h.push(f2._sb[w2]);
          f2._sb = [], f2.__h.length && u2.push(f2);
          break t;
        }
        null != f2.componentWillUpdate && f2.componentWillUpdate(v2, f2.__s, b2), null != f2.componentDidUpdate && f2.__h.push(function() {
          f2.componentDidUpdate(d2, h3, _2);
        });
      }
      if (f2.context = b2, f2.props = v2, f2.__v = n2, f2.__P = t3, x2 = c.__r, k = 0, "prototype" in E2 && E2.prototype.render) {
        for (f2.state = f2.__s, f2.__d = false, x2 && x2(n2), l2 = f2.render(f2.props, f2.state, f2.context), P2 = 0; P2 < f2._sb.length; P2++) f2.__h.push(f2._sb[P2]);
        f2._sb = [];
      } else do {
        f2.__d = false, x2 && x2(n2), l2 = f2.render(f2.props, f2.state, f2.context), f2.state = f2.__s;
      } while (f2.__d && ++k < 25);
      f2.state = f2.__s, null != f2.getChildContext && (r2 = g(g({}, r2), f2.getChildContext())), p2 || null == f2.getSnapshotBeforeUpdate || (_2 = f2.getSnapshotBeforeUpdate(d2, h3)), C2 = null != l2 && l2.type === S && null == l2.key ? l2.props.children : l2, T(t3, Array.isArray(C2) ? C2 : [C2], n2, e2, r2, o2, i2, u2, s2, a2), f2.base = n2.__e, n2.__h = null, f2.__h.length && u2.push(f2), m2 && (f2.__E = f2.__ = null), f2.__e = false;
    } else null == i2 && n2.__v === e2.__v ? (n2.__k = e2.__k, n2.__e = e2.__e) : n2.__e = R(e2.__e, n2, e2, r2, o2, i2, u2, a2);
    (l2 = c.diffed) && l2(n2);
  } catch (t4) {
    n2.__v = null, (a2 || null != i2) && (n2.__e = s2, n2.__h = !!a2, i2[i2.indexOf(s2)] = null), c.__e(t4, n2, e2);
  }
}
function F(t3, n2) {
  c.__c && c.__c(n2, t3), t3.some(function(n3) {
    try {
      t3 = n3.__h, n3.__h = [], t3.some(function(t4) {
        t4.call(n3);
      });
    } catch (t4) {
      c.__e(t4, n3.__v);
    }
  });
}
function R(t3, n2, e2, r2, o2, i2, u2, s2) {
  var a2, c2, f2, p2 = e2.props, d2 = n2.props, h3 = n2.type, _2 = 0;
  if ("svg" === h3 && (o2 = true), null != i2) {
    for (; _2 < i2.length; _2++) if ((a2 = i2[_2]) && "setAttribute" in a2 == !!h3 && (h3 ? a2.localName === h3 : 3 === a2.nodeType)) {
      t3 = a2, i2[_2] = null;
      break;
    }
  }
  if (null == t3) {
    if (null === h3) return document.createTextNode(d2);
    t3 = o2 ? document.createElementNS("http://www.w3.org/2000/svg", h3) : document.createElement(h3, d2.is && d2), i2 = null, s2 = false;
  }
  if (null === h3) p2 === d2 || s2 && t3.data === d2 || (t3.data = d2);
  else {
    if (i2 = i2 && l.call(t3.childNodes), c2 = (p2 = e2.props || m).dangerouslySetInnerHTML, f2 = d2.dangerouslySetInnerHTML, !s2) {
      if (null != i2) for (p2 = {}, _2 = 0; _2 < t3.attributes.length; _2++) p2[t3.attributes[_2].name] = t3.attributes[_2].value;
      (f2 || c2) && (f2 && (c2 && f2.__html == c2.__html || f2.__html === t3.innerHTML) || (t3.innerHTML = f2 && f2.__html || ""));
    }
    if ((function(t4, n3, e3, r3, o3) {
      var i3;
      for (i3 in e3) "children" === i3 || "key" === i3 || i3 in n3 || H(t4, i3, null, e3[i3], r3);
      for (i3 in n3) o3 && "function" != typeof n3[i3] || "children" === i3 || "key" === i3 || "value" === i3 || "checked" === i3 || e3[i3] === n3[i3] || H(t4, i3, n3[i3], e3[i3], r3);
    })(t3, d2, p2, o2, s2), f2) n2.__k = [];
    else if (_2 = n2.props.children, T(t3, Array.isArray(_2) ? _2 : [_2], n2, e2, r2, o2 && "foreignObject" !== h3, i2, u2, i2 ? i2[0] : e2.__k && P(e2, 0), s2), null != i2) for (_2 = i2.length; _2--; ) null != i2[_2] && b(i2[_2]);
    s2 || ("value" in d2 && void 0 !== (_2 = d2.value) && (_2 !== t3.value || "progress" === h3 && !_2 || "option" === h3 && _2 !== p2.value) && H(t3, "value", _2, p2.value, false), "checked" in d2 && void 0 !== (_2 = d2.checked) && _2 !== t3.checked && H(t3, "checked", _2, p2.checked, false));
  }
  return t3;
}
function U(t3, n2, e2) {
  try {
    "function" == typeof t3 ? t3(n2) : t3.current = n2;
  } catch (t4) {
    c.__e(t4, e2);
  }
}
function W(t3, n2, e2) {
  var r2, o2;
  if (c.unmount && c.unmount(t3), (r2 = t3.ref) && (r2.current && r2.current !== t3.__e || U(r2, null, n2)), null != (r2 = t3.__c)) {
    if (r2.componentWillUnmount) try {
      r2.componentWillUnmount();
    } catch (t4) {
      c.__e(t4, n2);
    }
    r2.base = r2.__P = null, t3.__c = void 0;
  }
  if (r2 = t3.__k) for (o2 = 0; o2 < r2.length; o2++) r2[o2] && W(r2[o2], n2, e2 || "function" != typeof t3.type);
  e2 || null == t3.__e || b(t3.__e), t3.__ = t3.__e = t3.__d = void 0;
}
function B(t3, n2, e2) {
  return this.constructor(t3, e2);
}
function q(t3, n2, e2) {
  var r2, o2, i2;
  c.__ && c.__(t3, n2), o2 = (r2 = "function" == typeof e2) ? null : e2 && e2.__k || n2.__k, i2 = [], M(n2, t3 = (!r2 && e2 || n2).__k = w(S, null, [t3]), o2 || m, m, void 0 !== n2.ownerSVGElement, !r2 && e2 ? [e2] : o2 ? null : n2.firstChild ? l.call(n2.childNodes) : null, i2, !r2 && e2 ? e2 : o2 ? o2.__e : n2.firstChild, r2), F(i2, t3);
}
function z() {
  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(t3) {
    var n2 = 16 * Math.random() | 0;
    return ("x" == t3 ? n2 : 3 & n2 | 8).toString(16);
  });
}
l = v.slice, c = { __e: function(t3, n2, e2, r2) {
  for (var o2, i2, u2; n2 = n2.__; ) if ((o2 = n2.__c) && !o2.__) try {
    if ((i2 = o2.constructor) && null != i2.getDerivedStateFromError && (o2.setState(i2.getDerivedStateFromError(t3)), u2 = o2.__d), null != o2.componentDidCatch && (o2.componentDidCatch(t3, r2 || {}), u2 = o2.__d), u2) return o2.__E = o2;
  } catch (n3) {
    t3 = n3;
  }
  throw t3;
} }, f = 0, p = function(t3) {
  return null != t3 && void 0 === t3.constructor;
}, N.prototype.setState = function(t3, n2) {
  var e2;
  e2 = null != this.__s && this.__s !== this.state ? this.__s : this.__s = g({}, this.state), "function" == typeof t3 && (t3 = t3(g({}, e2), this.props)), t3 && g(e2, t3), null != t3 && this.__v && (n2 && this._sb.push(n2), E(this));
}, N.prototype.forceUpdate = function(t3) {
  this.__v && (this.__e = true, t3 && this.__h.push(t3), E(this));
}, N.prototype.render = S, d = [], I.__r = 0, _ = 0;
var V = /* @__PURE__ */ (function() {
  function t3(t4) {
    this._id = void 0, this._id = t4 || z();
  }
  return n(t3, [{ key: "id", get: function() {
    return this._id;
  } }]), t3;
})();
function $(t3) {
  return w(t3.parentElement || "span", { dangerouslySetInnerHTML: { __html: t3.content } });
}
function G(t3, n2) {
  return w($, { content: t3, parentElement: n2 });
}
var K;
var X = /* @__PURE__ */ (function(t3) {
  function n2(n3) {
    var e3;
    return (e3 = t3.call(this) || this).data = void 0, e3.update(n3), e3;
  }
  r(n2, t3);
  var e2 = n2.prototype;
  return e2.cast = function(t4) {
    return t4 instanceof HTMLElement ? G(t4.outerHTML) : t4;
  }, e2.update = function(t4) {
    return this.data = this.cast(t4), this;
  }, n2;
})(V);
var Z = /* @__PURE__ */ (function(t3) {
  function e2(n2) {
    var e3;
    return (e3 = t3.call(this) || this)._cells = void 0, e3.cells = n2 || [], e3;
  }
  r(e2, t3);
  var o2 = e2.prototype;
  return o2.cell = function(t4) {
    return this._cells[t4];
  }, o2.toArray = function() {
    return this.cells.map(function(t4) {
      return t4.data;
    });
  }, e2.fromCells = function(t4) {
    return new e2(t4.map(function(t5) {
      return new X(t5.data);
    }));
  }, n(e2, [{ key: "cells", get: function() {
    return this._cells;
  }, set: function(t4) {
    this._cells = t4;
  } }, { key: "length", get: function() {
    return this.cells.length;
  } }]), e2;
})(V);
var J = /* @__PURE__ */ (function(t3) {
  function e2(n2) {
    var e3;
    return (e3 = t3.call(this) || this)._rows = void 0, e3._length = void 0, e3.rows = n2 instanceof Array ? n2 : n2 instanceof Z ? [n2] : [], e3;
  }
  return r(e2, t3), e2.prototype.toArray = function() {
    return this.rows.map(function(t4) {
      return t4.toArray();
    });
  }, e2.fromRows = function(t4) {
    return new e2(t4.map(function(t5) {
      return Z.fromCells(t5.cells);
    }));
  }, e2.fromArray = function(t4) {
    return new e2((t4 = (function(t5) {
      return !t5[0] || t5[0] instanceof Array ? t5 : [t5];
    })(t4)).map(function(t5) {
      return new Z(t5.map(function(t6) {
        return new X(t6);
      }));
    }));
  }, n(e2, [{ key: "rows", get: function() {
    return this._rows;
  }, set: function(t4) {
    this._rows = t4;
  } }, { key: "length", get: function() {
    return this._length || this.rows.length;
  }, set: function(t4) {
    this._length = t4;
  } }]), e2;
})(V);
var Q = /* @__PURE__ */ (function() {
  function t3() {
    this.callbacks = void 0;
  }
  var n2 = t3.prototype;
  return n2.init = function(t4) {
    this.callbacks || (this.callbacks = {}), t4 && !this.callbacks[t4] && (this.callbacks[t4] = []);
  }, n2.listeners = function() {
    return this.callbacks;
  }, n2.on = function(t4, n3) {
    return this.init(t4), this.callbacks[t4].push(n3), this;
  }, n2.off = function(t4, n3) {
    var e2 = t4;
    return this.init(), this.callbacks[e2] && 0 !== this.callbacks[e2].length ? (this.callbacks[e2] = this.callbacks[e2].filter(function(t5) {
      return t5 != n3;
    }), this) : this;
  }, n2.emit = function(t4) {
    var n3 = arguments, e2 = t4;
    return this.init(e2), this.callbacks[e2].length > 0 && (this.callbacks[e2].forEach(function(t5) {
      return t5.apply(void 0, [].slice.call(n3, 1));
    }), true);
  }, t3;
})();
function Y(t3, n2) {
  if (typeof t3 != typeof n2) return false;
  if (null === t3 && null === n2) return true;
  if ("object" != typeof t3) return t3 === n2;
  if (Array.isArray(t3) && Array.isArray(n2)) {
    if (t3.length !== n2.length) return false;
    for (var e2 = 0; e2 < t3.length; e2++) if (!Y(t3[e2], n2[e2])) return false;
    return true;
  }
  if (t3.hasOwnProperty("constructor") && n2.hasOwnProperty("constructor") && t3.hasOwnProperty("props") && n2.hasOwnProperty("props") && t3.hasOwnProperty("key") && n2.hasOwnProperty("key") && t3.hasOwnProperty("ref") && n2.hasOwnProperty("ref") && t3.hasOwnProperty("type") && n2.hasOwnProperty("type")) return Y(t3.props, n2.props);
  var r2 = Object.keys(t3), o2 = Object.keys(n2);
  if (r2.length !== o2.length) return false;
  for (var i2 = 0, u2 = r2; i2 < u2.length; i2++) {
    var s2 = u2[i2];
    if (!n2.hasOwnProperty(s2) || !Y(t3[s2], n2[s2])) return false;
  }
  return true;
}
!(function(t3) {
  t3[t3.Initiator = 0] = "Initiator", t3[t3.ServerFilter = 1] = "ServerFilter", t3[t3.ServerSort = 2] = "ServerSort", t3[t3.ServerLimit = 3] = "ServerLimit", t3[t3.Extractor = 4] = "Extractor", t3[t3.Transformer = 5] = "Transformer", t3[t3.Filter = 6] = "Filter", t3[t3.Sort = 7] = "Sort", t3[t3.Limit = 8] = "Limit";
})(K || (K = {}));
var tt = /* @__PURE__ */ (function(t3) {
  function o2(n2) {
    var e2;
    return (e2 = t3.call(this) || this).id = void 0, e2._props = void 0, e2._props = {}, e2.id = z(), n2 && e2.setProps(n2), e2;
  }
  r(o2, t3);
  var i2 = o2.prototype;
  return i2.process = function() {
    var t4 = [].slice.call(arguments);
    this.validateProps instanceof Function && this.validateProps.apply(this, t4), this.emit.apply(this, ["beforeProcess"].concat(t4));
    var n2 = this._process.apply(this, t4);
    return this.emit.apply(this, ["afterProcess"].concat(t4)), n2;
  }, i2.setProps = function(t4) {
    var n2 = e({}, this._props, t4);
    return Y(n2, this._props) || (this._props = n2, this.emit("propsUpdated", this)), this;
  }, n(o2, [{ key: "props", get: function() {
    return this._props;
  } }]), o2;
})(Q);
var nt = /* @__PURE__ */ (function(t3) {
  function e2() {
    return t3.apply(this, arguments) || this;
  }
  return r(e2, t3), e2.prototype._process = function(t4) {
    return this.props.keyword ? (n2 = String(this.props.keyword).trim(), e3 = this.props.columns, r2 = this.props.ignoreHiddenColumns, o2 = t4, i2 = this.props.selector, n2 = n2.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), new J(o2.rows.filter(function(t5, o3) {
      return t5.cells.some(function(t6, u2) {
        if (!t6) return false;
        if (r2 && e3 && e3[u2] && "object" == typeof e3[u2] && e3[u2].hidden) return false;
        var s2 = "";
        if ("function" == typeof i2) s2 = i2(t6.data, o3, u2);
        else if ("object" == typeof t6.data) {
          var a2 = t6.data;
          a2 && a2.props && a2.props.content && (s2 = a2.props.content);
        } else s2 = String(t6.data);
        return new RegExp(n2, "gi").test(s2);
      });
    }))) : t4;
    var n2, e3, r2, o2, i2;
  }, n(e2, [{ key: "type", get: function() {
    return K.Filter;
  } }]), e2;
})(tt);
function et() {
  var t3 = "gridjs";
  return "" + t3 + [].slice.call(arguments).reduce(function(t4, n2) {
    return t4 + "-" + n2;
  }, "");
}
function rt() {
  return [].slice.call(arguments).map(function(t3) {
    return t3 ? t3.toString() : "";
  }).filter(function(t3) {
    return t3;
  }).reduce(function(t3, n2) {
    return (t3 || "") + " " + n2;
  }, "").trim();
}
var ot;
var it2;
var ut;
var st;
var at = /* @__PURE__ */ (function(t3) {
  function o2() {
    return t3.apply(this, arguments) || this;
  }
  return r(o2, t3), o2.prototype._process = function(t4) {
    if (!this.props.keyword) return t4;
    var n2 = {};
    return this.props.url && (n2.url = this.props.url(t4.url, this.props.keyword)), this.props.body && (n2.body = this.props.body(t4.body, this.props.keyword)), e({}, t4, n2);
  }, n(o2, [{ key: "type", get: function() {
    return K.ServerFilter;
  } }]), o2;
})(tt);
var lt = 0;
var ct = [];
var ft = [];
var pt2 = c.__b;
var dt = c.__r;
var ht = c.diffed;
var _t = c.__c;
var mt = c.unmount;
function vt(t3, n2) {
  c.__h && c.__h(it2, t3, lt || n2), lt = 0;
  var e2 = it2.__H || (it2.__H = { __: [], __h: [] });
  return t3 >= e2.__.length && e2.__.push({ __V: ft }), e2.__[t3];
}
function yt(t3) {
  return lt = 1, (function(t4, n2, e2) {
    var r2 = vt(ot++, 2);
    if (r2.t = t4, !r2.__c && (r2.__ = [Et(void 0, n2), function(t5) {
      var n3 = r2.__N ? r2.__N[0] : r2.__[0], e3 = r2.t(n3, t5);
      n3 !== e3 && (r2.__N = [e3, r2.__[1]], r2.__c.setState({}));
    }], r2.__c = it2, !it2.u)) {
      it2.u = true;
      var o2 = it2.shouldComponentUpdate;
      it2.shouldComponentUpdate = function(t5, n3, e3) {
        if (!r2.__c.__H) return true;
        var i2 = r2.__c.__H.__.filter(function(t6) {
          return t6.__c;
        });
        if (i2.every(function(t6) {
          return !t6.__N;
        })) return !o2 || o2.call(this, t5, n3, e3);
        var u2 = false;
        return i2.forEach(function(t6) {
          if (t6.__N) {
            var n4 = t6.__[0];
            t6.__ = t6.__N, t6.__N = void 0, n4 !== t6.__[0] && (u2 = true);
          }
        }), !(!u2 && r2.__c.props === t5) && (!o2 || o2.call(this, t5, n3, e3));
      };
    }
    return r2.__N || r2.__;
  })(Et, t3);
}
function gt(t3, n2) {
  var e2 = vt(ot++, 3);
  !c.__s && Ct(e2.__H, n2) && (e2.__ = t3, e2.i = n2, it2.__H.__h.push(e2));
}
function bt(t3) {
  return lt = 5, wt(function() {
    return { current: t3 };
  }, []);
}
function wt(t3, n2) {
  var e2 = vt(ot++, 7);
  return Ct(e2.__H, n2) ? (e2.__V = t3(), e2.i = n2, e2.__h = t3, e2.__V) : e2.__;
}
function xt() {
  for (var t3; t3 = ct.shift(); ) if (t3.__P && t3.__H) try {
    t3.__H.__h.forEach(Nt), t3.__H.__h.forEach(Pt), t3.__H.__h = [];
  } catch (n2) {
    t3.__H.__h = [], c.__e(n2, t3.__v);
  }
}
c.__b = function(t3) {
  it2 = null, pt2 && pt2(t3);
}, c.__r = function(t3) {
  dt && dt(t3), ot = 0;
  var n2 = (it2 = t3.__c).__H;
  n2 && (ut === it2 ? (n2.__h = [], it2.__h = [], n2.__.forEach(function(t4) {
    t4.__N && (t4.__ = t4.__N), t4.__V = ft, t4.__N = t4.i = void 0;
  })) : (n2.__h.forEach(Nt), n2.__h.forEach(Pt), n2.__h = [])), ut = it2;
}, c.diffed = function(t3) {
  ht && ht(t3);
  var n2 = t3.__c;
  n2 && n2.__H && (n2.__H.__h.length && (1 !== ct.push(n2) && st === c.requestAnimationFrame || ((st = c.requestAnimationFrame) || St)(xt)), n2.__H.__.forEach(function(t4) {
    t4.i && (t4.__H = t4.i), t4.__V !== ft && (t4.__ = t4.__V), t4.i = void 0, t4.__V = ft;
  })), ut = it2 = null;
}, c.__c = function(t3, n2) {
  n2.some(function(t4) {
    try {
      t4.__h.forEach(Nt), t4.__h = t4.__h.filter(function(t5) {
        return !t5.__ || Pt(t5);
      });
    } catch (e2) {
      n2.some(function(t5) {
        t5.__h && (t5.__h = []);
      }), n2 = [], c.__e(e2, t4.__v);
    }
  }), _t && _t(t3, n2);
}, c.unmount = function(t3) {
  mt && mt(t3);
  var n2, e2 = t3.__c;
  e2 && e2.__H && (e2.__H.__.forEach(function(t4) {
    try {
      Nt(t4);
    } catch (t5) {
      n2 = t5;
    }
  }), e2.__H = void 0, n2 && c.__e(n2, e2.__v));
};
var kt = "function" == typeof requestAnimationFrame;
function St(t3) {
  var n2, e2 = function() {
    clearTimeout(r2), kt && cancelAnimationFrame(n2), setTimeout(t3);
  }, r2 = setTimeout(e2, 100);
  kt && (n2 = requestAnimationFrame(e2));
}
function Nt(t3) {
  var n2 = it2, e2 = t3.__c;
  "function" == typeof e2 && (t3.__c = void 0, e2()), it2 = n2;
}
function Pt(t3) {
  var n2 = it2;
  t3.__c = t3.__(), it2 = n2;
}
function Ct(t3, n2) {
  return !t3 || t3.length !== n2.length || n2.some(function(n3, e2) {
    return n3 !== t3[e2];
  });
}
function Et(t3, n2) {
  return "function" == typeof n2 ? n2(t3) : n2;
}
function It() {
  return (function(t3) {
    var n2 = it2.context[t3.__c], e2 = vt(ot++, 9);
    return e2.c = t3, n2 ? (null == e2.__ && (e2.__ = true, n2.sub(it2)), n2.props.value) : t3.__;
  })(fn);
}
var Tt = { search: { placeholder: "Type a keyword..." }, sort: { sortAsc: "Sort column ascending", sortDesc: "Sort column descending" }, pagination: { previous: "Previous", next: "Next", navigate: function(t3, n2) {
  return "Page " + t3 + " of " + n2;
}, page: function(t3) {
  return "Page " + t3;
}, showing: "Showing", of: "of", to: "to", results: "results" }, loading: "Loading...", noRecordsFound: "No matching records found", error: "An error happened while fetching the data" };
var Lt = /* @__PURE__ */ (function() {
  function t3(t4) {
    this._language = void 0, this._defaultLanguage = void 0, this._language = t4, this._defaultLanguage = Tt;
  }
  var n2 = t3.prototype;
  return n2.getString = function(t4, n3) {
    if (!n3 || !t4) return null;
    var e2 = t4.split("."), r2 = e2[0];
    if (n3[r2]) {
      var o2 = n3[r2];
      return "string" == typeof o2 ? function() {
        return o2;
      } : "function" == typeof o2 ? o2 : this.getString(e2.slice(1).join("."), o2);
    }
    return null;
  }, n2.translate = function(t4) {
    var n3, e2 = this.getString(t4, this._language);
    return (n3 = e2 || this.getString(t4, this._defaultLanguage)) ? n3.apply(void 0, [].slice.call(arguments, 1)) : t4;
  }, t3;
})();
function At() {
  var t3 = It();
  return function(n2) {
    var e2;
    return (e2 = t3.translator).translate.apply(e2, [n2].concat([].slice.call(arguments, 1)));
  };
}
var Ot = function(t3) {
  return function(n2) {
    return e({}, n2, { search: { keyword: t3 } });
  };
};
function Ht() {
  return It().store;
}
function jt(t3) {
  var n2 = Ht(), e2 = yt(t3(n2.getState())), r2 = e2[0], o2 = e2[1];
  return gt(function() {
    return n2.subscribe(function() {
      var e3 = t3(n2.getState());
      r2 !== e3 && o2(e3);
    });
  }, []), r2;
}
function Dt() {
  var t3, n2 = yt(void 0), e2 = n2[0], r2 = n2[1], o2 = It(), i2 = o2.search, u2 = At(), s2 = Ht().dispatch, a2 = jt(function(t4) {
    return t4.search;
  });
  gt(function() {
    e2 && e2.setProps({ keyword: null == a2 ? void 0 : a2.keyword });
  }, [a2, e2]), gt(function() {
    r2(i2.server ? new at({ keyword: i2.keyword, url: i2.server.url, body: i2.server.body }) : new nt({ keyword: i2.keyword, columns: o2.header && o2.header.columns, ignoreHiddenColumns: i2.ignoreHiddenColumns || void 0 === i2.ignoreHiddenColumns, selector: i2.selector })), i2.keyword && s2(Ot(i2.keyword));
  }, [i2]), gt(function() {
    if (e2) return o2.pipeline.register(e2), function() {
      return o2.pipeline.unregister(e2);
    };
  }, [o2, e2]);
  var l2, c2, f2, p2 = (function(t4, n3) {
    return lt = 8, wt(function() {
      return t4;
    }, n3);
  })((l2 = function(t4) {
    t4.target instanceof HTMLInputElement && s2(Ot(t4.target.value));
  }, c2 = e2 instanceof at ? i2.debounceTimeout || 250 : 0, function() {
    var t4 = arguments;
    return new Promise(function(n3) {
      f2 && clearTimeout(f2), f2 = setTimeout(function() {
        return n3(l2.apply(void 0, [].slice.call(t4)));
      }, c2);
    });
  }), [i2, e2]);
  return w("div", { className: et(rt("search", null == (t3 = o2.className) ? void 0 : t3.search)) }, w("input", { type: "search", placeholder: u2("search.placeholder"), "aria-label": u2("search.placeholder"), onInput: p2, className: rt(et("input"), et("search", "input")), defaultValue: (null == a2 ? void 0 : a2.keyword) || "" }));
}
var Mt = /* @__PURE__ */ (function(t3) {
  function e2() {
    return t3.apply(this, arguments) || this;
  }
  r(e2, t3);
  var o2 = e2.prototype;
  return o2.validateProps = function() {
    if (isNaN(Number(this.props.limit)) || isNaN(Number(this.props.page))) throw Error("Invalid parameters passed");
  }, o2._process = function(t4) {
    var n2 = this.props.page;
    return new J(t4.rows.slice(n2 * this.props.limit, (n2 + 1) * this.props.limit));
  }, n(e2, [{ key: "type", get: function() {
    return K.Limit;
  } }]), e2;
})(tt);
var Ft = /* @__PURE__ */ (function(t3) {
  function o2() {
    return t3.apply(this, arguments) || this;
  }
  return r(o2, t3), o2.prototype._process = function(t4) {
    var n2 = {};
    return this.props.url && (n2.url = this.props.url(t4.url, this.props.page, this.props.limit)), this.props.body && (n2.body = this.props.body(t4.body, this.props.page, this.props.limit)), e({}, t4, n2);
  }, n(o2, [{ key: "type", get: function() {
    return K.ServerLimit;
  } }]), o2;
})(tt);
function Rt() {
  var t3 = It(), n2 = t3.pagination, e2 = n2.server, r2 = n2.summary, o2 = void 0 === r2 || r2, i2 = n2.nextButton, u2 = void 0 === i2 || i2, s2 = n2.prevButton, a2 = void 0 === s2 || s2, l2 = n2.buttonsCount, c2 = void 0 === l2 ? 3 : l2, f2 = n2.limit, p2 = void 0 === f2 ? 10 : f2, d2 = n2.page, h3 = void 0 === d2 ? 0 : d2, _2 = n2.resetPageOnUpdate, m2 = void 0 === _2 || _2, v2 = bt(null), y2 = yt(h3), g2 = y2[0], b2 = y2[1], x2 = yt(0), k = x2[0], N2 = x2[1], P2 = At();
  gt(function() {
    return e2 ? (v2.current = new Ft({ limit: p2, page: g2, url: e2.url, body: e2.body }), t3.pipeline.register(v2.current)) : (v2.current = new Mt({ limit: p2, page: g2 }), t3.pipeline.register(v2.current)), v2.current instanceof Ft ? t3.pipeline.on("afterProcess", function(t4) {
      return N2(t4.length);
    }) : v2.current instanceof Mt && v2.current.on("beforeProcess", function(t4) {
      return N2(t4.length);
    }), t3.pipeline.on("updated", C2), t3.pipeline.on("error", function() {
      N2(0), b2(0);
    }), function() {
      t3.pipeline.unregister(v2.current), t3.pipeline.off("updated", C2);
    };
  }, []);
  var C2 = function(t4) {
    m2 && t4 !== v2.current && (b2(0), 0 !== v2.current.props.page && v2.current.setProps({ page: 0 }));
  }, E2 = function() {
    return Math.ceil(k / p2);
  }, I2 = function(t4) {
    if (t4 >= E2() || t4 < 0 || t4 === g2) return null;
    b2(t4), v2.current.setProps({ page: t4 });
  };
  return w("div", { className: rt(et("pagination"), t3.className.pagination) }, w(S, null, o2 && k > 0 && w("div", { role: "status", "aria-live": "polite", className: rt(et("summary"), t3.className.paginationSummary), title: P2("pagination.navigate", g2 + 1, E2()) }, P2("pagination.showing"), " ", w("b", null, P2("" + (g2 * p2 + 1))), " ", P2("pagination.to"), " ", w("b", null, P2("" + Math.min((g2 + 1) * p2, k))), " ", P2("pagination.of"), " ", w("b", null, P2("" + k)), " ", P2("pagination.results"))), w("div", { className: et("pages") }, a2 && w("button", { tabIndex: 0, role: "button", disabled: 0 === g2, onClick: function() {
    return I2(g2 - 1);
  }, title: P2("pagination.previous"), "aria-label": P2("pagination.previous"), className: rt(t3.className.paginationButton, t3.className.paginationButtonPrev) }, P2("pagination.previous")), (function() {
    if (c2 <= 0) return null;
    var n3 = Math.min(E2(), c2), e3 = Math.min(g2, Math.floor(n3 / 2));
    return g2 + Math.floor(n3 / 2) >= E2() && (e3 = n3 - (E2() - g2)), w(S, null, E2() > n3 && g2 - e3 > 0 && w(S, null, w("button", { tabIndex: 0, role: "button", onClick: function() {
      return I2(0);
    }, title: P2("pagination.firstPage"), "aria-label": P2("pagination.firstPage"), className: t3.className.paginationButton }, P2("1")), w("button", { tabIndex: -1, className: rt(et("spread"), t3.className.paginationButton) }, "...")), Array.from(Array(n3).keys()).map(function(t4) {
      return g2 + (t4 - e3);
    }).map(function(n4) {
      return w("button", { tabIndex: 0, role: "button", onClick: function() {
        return I2(n4);
      }, className: rt(g2 === n4 ? rt(et("currentPage"), t3.className.paginationButtonCurrent) : null, t3.className.paginationButton), title: P2("pagination.page", n4 + 1), "aria-label": P2("pagination.page", n4 + 1) }, P2("" + (n4 + 1)));
    }), E2() > n3 && E2() > g2 + e3 + 1 && w(S, null, w("button", { tabIndex: -1, className: rt(et("spread"), t3.className.paginationButton) }, "..."), w("button", { tabIndex: 0, role: "button", onClick: function() {
      return I2(E2() - 1);
    }, title: P2("pagination.page", E2()), "aria-label": P2("pagination.page", E2()), className: t3.className.paginationButton }, P2("" + E2()))));
  })(), u2 && w("button", { tabIndex: 0, role: "button", disabled: E2() === g2 + 1 || 0 === E2(), onClick: function() {
    return I2(g2 + 1);
  }, title: P2("pagination.next"), "aria-label": P2("pagination.next"), className: rt(t3.className.paginationButton, t3.className.paginationButtonNext) }, P2("pagination.next"))));
}
function Ut(t3, n2) {
  return "string" == typeof t3 ? t3.indexOf("%") > -1 ? n2 / 100 * parseInt(t3, 10) : parseInt(t3, 10) : t3;
}
function Wt(t3) {
  return t3 ? Math.floor(t3) + "px" : "";
}
function Bt(t3) {
  var n2 = t3.tableRef.cloneNode(true);
  return n2.style.position = "absolute", n2.style.width = "100%", n2.style.zIndex = "-2147483640", n2.style.visibility = "hidden", w("div", { ref: function(t4) {
    t4 && t4.appendChild(n2);
  } });
}
function qt(t3) {
  if (!t3) return "";
  var n2 = t3.split(" ");
  return 1 === n2.length && /([a-z][A-Z])+/g.test(t3) ? t3 : n2.map(function(t4, n3) {
    return 0 == n3 ? t4.toLowerCase() : t4.charAt(0).toUpperCase() + t4.slice(1).toLowerCase();
  }).join("");
}
var zt;
var Vt = new (/* @__PURE__ */ (function() {
  function t3() {
  }
  var n2 = t3.prototype;
  return n2.format = function(t4, n3) {
    return "[Grid.js] [" + n3.toUpperCase() + "]: " + t4;
  }, n2.error = function(t4, n3) {
    void 0 === n3 && (n3 = false);
    var e2 = this.format(t4, "error");
    if (n3) throw Error(e2);
    console.error(e2);
  }, n2.warn = function(t4) {
    console.warn(this.format(t4, "warn"));
  }, n2.info = function(t4) {
    console.info(this.format(t4, "info"));
  }, t3;
})())();
!(function(t3) {
  t3[t3.Header = 0] = "Header", t3[t3.Footer = 1] = "Footer", t3[t3.Cell = 2] = "Cell";
})(zt || (zt = {}));
var $t = /* @__PURE__ */ (function() {
  function t3() {
    this.plugins = void 0, this.plugins = [];
  }
  var n2 = t3.prototype;
  return n2.get = function(t4) {
    return this.plugins.find(function(n3) {
      return n3.id === t4;
    });
  }, n2.add = function(t4) {
    return t4.id ? this.get(t4.id) ? (Vt.error("Duplicate plugin ID: " + t4.id), this) : (this.plugins.push(t4), this) : (Vt.error("Plugin ID cannot be empty"), this);
  }, n2.remove = function(t4) {
    var n3 = this.get(t4);
    return n3 && this.plugins.splice(this.plugins.indexOf(n3), 1), this;
  }, n2.list = function(t4) {
    var n3;
    return n3 = null != t4 || null != t4 ? this.plugins.filter(function(n4) {
      return n4.position === t4;
    }) : this.plugins, n3.sort(function(t5, n4) {
      return t5.order && n4.order ? t5.order - n4.order : 1;
    });
  }, t3;
})();
function Gt(t3) {
  var n2 = this, r2 = It();
  if (t3.pluginId) {
    var o2 = r2.plugin.get(t3.pluginId);
    return o2 ? w(S, {}, w(o2.component, e({ plugin: o2 }, t3.props))) : null;
  }
  return void 0 !== t3.position ? w(S, {}, r2.plugin.list(t3.position).map(function(t4) {
    return w(t4.component, e({ plugin: t4 }, n2.props.props));
  })) : null;
}
var Kt = /* @__PURE__ */ (function(t3) {
  function o2() {
    var n2;
    return (n2 = t3.call(this) || this)._columns = void 0, n2._columns = [], n2;
  }
  r(o2, t3);
  var i2 = o2.prototype;
  return i2.adjustWidth = function(t4, n2, r2) {
    var i3 = t4.container, u2 = t4.autoWidth;
    if (!i3) return this;
    var a2 = i3.clientWidth, l2 = {};
    n2.current && u2 && (q(w(Bt, { tableRef: n2.current }), r2.current), l2 = (function(t5) {
      var n3 = t5.querySelector("table");
      if (!n3) return {};
      var r3 = n3.className, o3 = n3.style.cssText;
      n3.className = r3 + " " + et("shadowTable"), n3.style.tableLayout = "auto", n3.style.width = "auto", n3.style.padding = "0", n3.style.margin = "0", n3.style.border = "none", n3.style.outline = "none";
      var i4 = Array.from(n3.parentNode.querySelectorAll("thead th")).reduce(function(t6, n4) {
        var r4;
        return n4.style.width = n4.clientWidth + "px", e(((r4 = {})[n4.getAttribute("data-column-id")] = { minWidth: n4.clientWidth }, r4), t6);
      }, {});
      return n3.className = r3, n3.style.cssText = o3, n3.style.tableLayout = "auto", Array.from(n3.parentNode.querySelectorAll("thead th")).reduce(function(t6, n4) {
        return t6[n4.getAttribute("data-column-id")].width = n4.clientWidth, t6;
      }, i4);
    })(r2.current));
    for (var c2, f2 = s(o2.tabularFormat(this.columns).reduce(function(t5, n3) {
      return t5.concat(n3);
    }, [])); !(c2 = f2()).done; ) {
      var p2 = c2.value;
      p2.columns && p2.columns.length > 0 || (!p2.width && u2 ? p2.id in l2 && (p2.width = Wt(l2[p2.id].width), p2.minWidth = Wt(l2[p2.id].minWidth)) : p2.width = Wt(Ut(p2.width, a2)));
    }
    return n2.current && u2 && q(null, r2.current), this;
  }, i2.setSort = function(t4, n2) {
    for (var r2, o3 = s(n2 || this.columns || []); !(r2 = o3()).done; ) {
      var i3 = r2.value;
      i3.columns && i3.columns.length > 0 ? i3.sort = void 0 : void 0 === i3.sort && t4 ? i3.sort = {} : i3.sort ? "object" == typeof i3.sort && (i3.sort = e({}, i3.sort)) : i3.sort = void 0, i3.columns && this.setSort(t4, i3.columns);
    }
  }, i2.setResizable = function(t4, n2) {
    for (var e2, r2 = s(n2 || this.columns || []); !(e2 = r2()).done; ) {
      var o3 = e2.value;
      void 0 === o3.resizable && (o3.resizable = t4), o3.columns && this.setResizable(t4, o3.columns);
    }
  }, i2.setID = function(t4) {
    for (var n2, e2 = s(t4 || this.columns || []); !(n2 = e2()).done; ) {
      var r2 = n2.value;
      r2.id || "string" != typeof r2.name || (r2.id = qt(r2.name)), r2.id || Vt.error('Could not find a valid ID for one of the columns. Make sure a valid "id" is set for all columns.'), r2.columns && this.setID(r2.columns);
    }
  }, i2.populatePlugins = function(t4, n2) {
    for (var r2, o3 = s(n2); !(r2 = o3()).done; ) {
      var i3 = r2.value;
      void 0 !== i3.plugin && t4.add(e({ id: i3.id }, i3.plugin, { position: zt.Cell }));
    }
  }, o2.fromColumns = function(t4) {
    for (var n2, e2 = new o2(), r2 = s(t4); !(n2 = r2()).done; ) {
      var i3 = n2.value;
      if ("string" == typeof i3 || p(i3)) e2.columns.push({ name: i3 });
      else if ("object" == typeof i3) {
        var u2 = i3;
        u2.columns && (u2.columns = o2.fromColumns(u2.columns).columns), "object" == typeof u2.plugin && void 0 === u2.data && (u2.data = null), e2.columns.push(i3);
      }
    }
    return e2;
  }, o2.createFromConfig = function(t4) {
    var n2 = new o2();
    return t4.from ? n2.columns = o2.fromHTMLTable(t4.from).columns : t4.columns ? n2.columns = o2.fromColumns(t4.columns).columns : !t4.data || "object" != typeof t4.data[0] || t4.data[0] instanceof Array || (n2.columns = Object.keys(t4.data[0]).map(function(t5) {
      return { name: t5 };
    })), n2.columns.length ? (n2.setID(), n2.setSort(t4.sort), n2.setResizable(t4.resizable), n2.populatePlugins(t4.plugin, n2.columns), n2) : null;
  }, o2.fromHTMLTable = function(t4) {
    for (var n2, e2 = new o2(), r2 = s(t4.querySelector("thead").querySelectorAll("th")); !(n2 = r2()).done; ) {
      var i3 = n2.value;
      e2.columns.push({ name: i3.innerHTML, width: i3.width });
    }
    return e2;
  }, o2.tabularFormat = function(t4) {
    var n2 = [], e2 = t4 || [], r2 = [];
    if (e2 && e2.length) {
      n2.push(e2);
      for (var o3, i3 = s(e2); !(o3 = i3()).done; ) {
        var u2 = o3.value;
        u2.columns && u2.columns.length && (r2 = r2.concat(u2.columns));
      }
      r2.length && (n2 = n2.concat(this.tabularFormat(r2)));
    }
    return n2;
  }, o2.leafColumns = function(t4) {
    var n2 = [], e2 = t4 || [];
    if (e2 && e2.length) for (var r2, o3 = s(e2); !(r2 = o3()).done; ) {
      var i3 = r2.value;
      i3.columns && 0 !== i3.columns.length || n2.push(i3), i3.columns && (n2 = n2.concat(this.leafColumns(i3.columns)));
    }
    return n2;
  }, o2.maximumDepth = function(t4) {
    return this.tabularFormat([t4]).length - 1;
  }, n(o2, [{ key: "columns", get: function() {
    return this._columns;
  }, set: function(t4) {
    this._columns = t4;
  } }, { key: "visibleColumns", get: function() {
    return this._columns.filter(function(t4) {
      return !t4.hidden;
    });
  } }]), o2;
})(V);
var Xt = function() {
};
var Zt = /* @__PURE__ */ (function(t3) {
  function n2(n3) {
    var e3;
    return (e3 = t3.call(this) || this).data = void 0, e3.set(n3), e3;
  }
  r(n2, t3);
  var e2 = n2.prototype;
  return e2.get = function() {
    try {
      return Promise.resolve(this.data()).then(function(t4) {
        return { data: t4, total: t4.length };
      });
    } catch (t4) {
      return Promise.reject(t4);
    }
  }, e2.set = function(t4) {
    return t4 instanceof Array ? this.data = function() {
      return t4;
    } : t4 instanceof Function && (this.data = t4), this;
  }, n2;
})(Xt);
var Jt = /* @__PURE__ */ (function(t3) {
  function n2(n3) {
    var e2;
    return (e2 = t3.call(this) || this).options = void 0, e2.options = n3, e2;
  }
  r(n2, t3);
  var o2 = n2.prototype;
  return o2.handler = function(t4) {
    return "function" == typeof this.options.handle ? this.options.handle(t4) : t4.ok ? t4.json() : (Vt.error("Could not fetch data: " + t4.status + " - " + t4.statusText, true), null);
  }, o2.get = function(t4) {
    var n3 = e({}, this.options, t4);
    return "function" == typeof n3.data ? n3.data(n3) : fetch(n3.url, n3).then(this.handler.bind(this)).then(function(t5) {
      return { data: n3.then(t5), total: "function" == typeof n3.total ? n3.total(t5) : void 0 };
    });
  }, n2;
})(Xt);
var Qt = /* @__PURE__ */ (function() {
  function t3() {
  }
  return t3.createFromConfig = function(t4) {
    var n2 = null;
    return t4.data && (n2 = new Zt(t4.data)), t4.from && (n2 = new Zt(this.tableElementToArray(t4.from)), t4.from.style.display = "none"), t4.server && (n2 = new Jt(t4.server)), n2 || Vt.error("Could not determine the storage type", true), n2;
  }, t3.tableElementToArray = function(t4) {
    for (var n2, e2, r2 = [], o2 = s(t4.querySelector("tbody").querySelectorAll("tr")); !(n2 = o2()).done; ) {
      for (var i2, u2 = [], a2 = s(n2.value.querySelectorAll("td")); !(i2 = a2()).done; ) {
        var l2 = i2.value;
        1 === l2.childNodes.length && l2.childNodes[0].nodeType === Node.TEXT_NODE ? u2.push((e2 = l2.innerHTML, new DOMParser().parseFromString(e2, "text/html").documentElement.textContent)) : u2.push(G(l2.innerHTML));
      }
      r2.push(u2);
    }
    return r2;
  }, t3;
})();
var Yt = "undefined" != typeof Symbol ? Symbol.iterator || (Symbol.iterator = /* @__PURE__ */ Symbol("Symbol.iterator")) : "@@iterator";
function tn(t3, n2, e2) {
  if (!t3.s) {
    if (e2 instanceof nn) {
      if (!e2.s) return void (e2.o = tn.bind(null, t3, n2));
      1 & n2 && (n2 = e2.s), e2 = e2.v;
    }
    if (e2 && e2.then) return void e2.then(tn.bind(null, t3, n2), tn.bind(null, t3, 2));
    t3.s = n2, t3.v = e2;
    var r2 = t3.o;
    r2 && r2(t3);
  }
}
var nn = /* @__PURE__ */ (function() {
  function t3() {
  }
  return t3.prototype.then = function(n2, e2) {
    var r2 = new t3(), o2 = this.s;
    if (o2) {
      var i2 = 1 & o2 ? n2 : e2;
      if (i2) {
        try {
          tn(r2, 1, i2(this.v));
        } catch (t4) {
          tn(r2, 2, t4);
        }
        return r2;
      }
      return this;
    }
    return this.o = function(t4) {
      try {
        var o3 = t4.v;
        1 & t4.s ? tn(r2, 1, n2 ? n2(o3) : o3) : e2 ? tn(r2, 1, e2(o3)) : tn(r2, 2, o3);
      } catch (t5) {
        tn(r2, 2, t5);
      }
    }, r2;
  }, t3;
})();
function en2(t3) {
  return t3 instanceof nn && 1 & t3.s;
}
var rn = /* @__PURE__ */ (function(t3) {
  function e2(n2) {
    var e3;
    return (e3 = t3.call(this) || this)._steps = /* @__PURE__ */ new Map(), e3.cache = /* @__PURE__ */ new Map(), e3.lastProcessorIndexUpdated = -1, n2 && n2.forEach(function(t4) {
      return e3.register(t4);
    }), e3;
  }
  r(e2, t3);
  var o2 = e2.prototype;
  return o2.clearCache = function() {
    this.cache = /* @__PURE__ */ new Map(), this.lastProcessorIndexUpdated = -1;
  }, o2.register = function(t4, n2) {
    if (void 0 === n2 && (n2 = null), !t4) throw Error("Processor is not defined");
    if (null === t4.type) throw Error("Processor type is not defined");
    if (this.findProcessorIndexByID(t4.id) > -1) throw Error("Processor ID " + t4.id + " is already defined");
    return t4.on("propsUpdated", this.processorPropsUpdated.bind(this)), this.addProcessorByPriority(t4, n2), this.afterRegistered(t4), t4;
  }, o2.tryRegister = function(t4, n2) {
    void 0 === n2 && (n2 = null);
    try {
      return this.register(t4, n2);
    } catch (t5) {
    }
  }, o2.unregister = function(t4) {
    if (t4 && -1 !== this.findProcessorIndexByID(t4.id)) {
      var n2 = this._steps.get(t4.type);
      n2 && n2.length && (this._steps.set(t4.type, n2.filter(function(n3) {
        return n3 != t4;
      })), this.emit("updated", t4));
    }
  }, o2.addProcessorByPriority = function(t4, n2) {
    var e3 = this._steps.get(t4.type);
    if (!e3) {
      var r2 = [];
      this._steps.set(t4.type, r2), e3 = r2;
    }
    if (null === n2 || n2 < 0) e3.push(t4);
    else if (e3[n2]) {
      var o3 = e3.slice(0, n2 - 1), i2 = e3.slice(n2 + 1);
      this._steps.set(t4.type, o3.concat(t4).concat(i2));
    } else e3[n2] = t4;
  }, o2.getStepsByType = function(t4) {
    return this.steps.filter(function(n2) {
      return n2.type === t4;
    });
  }, o2.getSortedProcessorTypes = function() {
    return Object.keys(K).filter(function(t4) {
      return !isNaN(Number(t4));
    }).map(function(t4) {
      return Number(t4);
    });
  }, o2.process = function(t4) {
    try {
      var n2 = function(t5) {
        return e3.lastProcessorIndexUpdated = o3.length, e3.emit("afterProcess", i2), i2;
      }, e3 = this, r2 = e3.lastProcessorIndexUpdated, o3 = e3.steps, i2 = t4, u2 = (function(t5, n3) {
        try {
          var u3 = (function(t6, n4, e4) {
            if ("function" == typeof t6[Yt]) {
              var r3, o4, i3, u4 = t6[Yt]();
              if ((function t7(e5) {
                try {
                  for (; !(r3 = u4.next()).done; ) if ((e5 = n4(r3.value)) && e5.then) {
                    if (!en2(e5)) return void e5.then(t7, i3 || (i3 = tn.bind(null, o4 = new nn(), 2)));
                    e5 = e5.v;
                  }
                  o4 ? tn(o4, 1, e5) : o4 = e5;
                } catch (t8) {
                  tn(o4 || (o4 = new nn()), 2, t8);
                }
              })(), u4.return) {
                var s2 = function(t7) {
                  try {
                    r3.done || u4.return();
                  } catch (t8) {
                  }
                  return t7;
                };
                if (o4 && o4.then) return o4.then(s2, function(t7) {
                  throw s2(t7);
                });
                s2();
              }
              return o4;
            }
            if (!("length" in t6)) throw new TypeError("Object is not iterable");
            for (var a2 = [], l2 = 0; l2 < t6.length; l2++) a2.push(t6[l2]);
            return (function(t7, n5, e5) {
              var r4, o5, i4 = -1;
              return (function e6(u5) {
                try {
                  for (; ++i4 < t7.length; ) if ((u5 = n5(i4)) && u5.then) {
                    if (!en2(u5)) return void u5.then(e6, o5 || (o5 = tn.bind(null, r4 = new nn(), 2)));
                    u5 = u5.v;
                  }
                  r4 ? tn(r4, 1, u5) : r4 = u5;
                } catch (t8) {
                  tn(r4 || (r4 = new nn()), 2, t8);
                }
              })(), r4;
            })(a2, function(t7) {
              return n4(a2[t7]);
            });
          })(o3, function(t6) {
            var n4 = e3.findProcessorIndexByID(t6.id), o4 = (function() {
              if (n4 >= r2) return Promise.resolve(t6.process(i2)).then(function(n5) {
                e3.cache.set(t6.id, i2 = n5);
              });
              i2 = e3.cache.get(t6.id);
            })();
            if (o4 && o4.then) return o4.then(function() {
            });
          });
        } catch (t6) {
          return n3(t6);
        }
        return u3 && u3.then ? u3.then(void 0, n3) : u3;
      })(0, function(t5) {
        throw Vt.error(t5), e3.emit("error", i2), t5;
      });
      return Promise.resolve(u2 && u2.then ? u2.then(n2) : n2());
    } catch (t5) {
      return Promise.reject(t5);
    }
  }, o2.findProcessorIndexByID = function(t4) {
    return this.steps.findIndex(function(n2) {
      return n2.id == t4;
    });
  }, o2.setLastProcessorIndex = function(t4) {
    var n2 = this.findProcessorIndexByID(t4.id);
    this.lastProcessorIndexUpdated > n2 && (this.lastProcessorIndexUpdated = n2);
  }, o2.processorPropsUpdated = function(t4) {
    this.setLastProcessorIndex(t4), this.emit("propsUpdated"), this.emit("updated", t4);
  }, o2.afterRegistered = function(t4) {
    this.setLastProcessorIndex(t4), this.emit("afterRegister"), this.emit("updated", t4);
  }, n(e2, [{ key: "steps", get: function() {
    for (var t4, n2 = [], e3 = s(this.getSortedProcessorTypes()); !(t4 = e3()).done; ) {
      var r2 = this._steps.get(t4.value);
      r2 && r2.length && (n2 = n2.concat(r2));
    }
    return n2.filter(function(t5) {
      return t5;
    });
  } }]), e2;
})(Q);
var on = /* @__PURE__ */ (function(t3) {
  function e2() {
    return t3.apply(this, arguments) || this;
  }
  return r(e2, t3), e2.prototype._process = function(t4) {
    try {
      return Promise.resolve(this.props.storage.get(t4));
    } catch (t5) {
      return Promise.reject(t5);
    }
  }, n(e2, [{ key: "type", get: function() {
    return K.Extractor;
  } }]), e2;
})(tt);
var un = /* @__PURE__ */ (function(t3) {
  function e2() {
    return t3.apply(this, arguments) || this;
  }
  return r(e2, t3), e2.prototype._process = function(t4) {
    var n2 = J.fromArray(t4.data);
    return n2.length = t4.total, n2;
  }, n(e2, [{ key: "type", get: function() {
    return K.Transformer;
  } }]), e2;
})(tt);
var sn = /* @__PURE__ */ (function(t3) {
  function o2() {
    return t3.apply(this, arguments) || this;
  }
  return r(o2, t3), o2.prototype._process = function() {
    return Object.entries(this.props.serverStorageOptions).filter(function(t4) {
      return "function" != typeof t4[1];
    }).reduce(function(t4, n2) {
      var r2;
      return e({}, t4, ((r2 = {})[n2[0]] = n2[1], r2));
    }, {});
  }, n(o2, [{ key: "type", get: function() {
    return K.Initiator;
  } }]), o2;
})(tt);
var an = /* @__PURE__ */ (function(t3) {
  function e2() {
    return t3.apply(this, arguments) || this;
  }
  r(e2, t3);
  var o2 = e2.prototype;
  return o2.castData = function(t4) {
    if (!t4 || !t4.length) return [];
    if (!this.props.header || !this.props.header.columns) return t4;
    var n2 = Kt.leafColumns(this.props.header.columns);
    return t4[0] instanceof Array ? t4.map(function(t5) {
      var e3 = 0;
      return n2.map(function(n3, r2) {
        return void 0 !== n3.data ? (e3++, "function" == typeof n3.data ? n3.data(t5) : n3.data) : t5[r2 - e3];
      });
    }) : "object" != typeof t4[0] || t4[0] instanceof Array ? [] : t4.map(function(t5) {
      return n2.map(function(n3, e3) {
        return void 0 !== n3.data ? "function" == typeof n3.data ? n3.data(t5) : n3.data : n3.id ? t5[n3.id] : (Vt.error("Could not find the correct cell for column at position " + e3 + ".\n                          Make sure either 'id' or 'selector' is defined for all columns."), null);
      });
    });
  }, o2._process = function(t4) {
    return { data: this.castData(t4.data), total: t4.total };
  }, n(e2, [{ key: "type", get: function() {
    return K.Transformer;
  } }]), e2;
})(tt);
var ln = /* @__PURE__ */ (function() {
  function t3() {
  }
  return t3.createFromConfig = function(t4) {
    var n2 = new rn();
    return t4.storage instanceof Jt && n2.register(new sn({ serverStorageOptions: t4.server })), n2.register(new on({ storage: t4.storage })), n2.register(new an({ header: t4.header })), n2.register(new un()), n2;
  }, t3;
})();
var cn = function(t3) {
  var n2 = this;
  this.state = void 0, this.listeners = [], this.isDispatching = false, this.getState = function() {
    return n2.state;
  }, this.getListeners = function() {
    return n2.listeners;
  }, this.dispatch = function(t4) {
    if ("function" != typeof t4) throw new Error("Reducer is not a function");
    if (n2.isDispatching) throw new Error("Reducers may not dispatch actions");
    n2.isDispatching = true;
    var e2 = n2.state;
    try {
      n2.state = t4(n2.state);
    } finally {
      n2.isDispatching = false;
    }
    for (var r2, o2 = s(n2.listeners); !(r2 = o2()).done; ) (0, r2.value)(n2.state, e2);
    return n2.state;
  }, this.subscribe = function(t4) {
    if ("function" != typeof t4) throw new Error("Listener is not a function");
    return n2.listeners = [].concat(n2.listeners, [t4]), function() {
      return n2.listeners = n2.listeners.filter(function(n3) {
        return n3 !== t4;
      });
    };
  }, this.state = t3;
};
var fn = (function(t3, n2) {
  var e2 = { __c: n2 = "__cC" + _++, __: null, Consumer: function(t4, n3) {
    return t4.children(n3);
  }, Provider: function(t4) {
    var e3, r2;
    return this.getChildContext || (e3 = [], (r2 = {})[n2] = this, this.getChildContext = function() {
      return r2;
    }, this.shouldComponentUpdate = function(t5) {
      this.props.value !== t5.value && e3.some(E);
    }, this.sub = function(t5) {
      e3.push(t5);
      var n3 = t5.componentWillUnmount;
      t5.componentWillUnmount = function() {
        e3.splice(e3.indexOf(t5), 1), n3 && n3.call(t5);
      };
    }), t4.children;
  } };
  return e2.Provider.__ = e2.Consumer.contextType = e2;
})();
var pn = /* @__PURE__ */ (function() {
  function t3() {
    Object.assign(this, t3.defaultConfig());
  }
  var n2 = t3.prototype;
  return n2.assign = function(t4) {
    return Object.assign(this, t4);
  }, n2.update = function(n3) {
    return n3 ? (this.assign(t3.fromPartialConfig(e({}, this, n3))), this) : this;
  }, t3.defaultConfig = function() {
    return { store: new cn({ status: a.Init, header: void 0, data: null }), plugin: new $t(), tableRef: { current: null }, width: "100%", height: "auto", processingThrottleMs: 100, autoWidth: true, style: {}, className: {} };
  }, t3.fromPartialConfig = function(n3) {
    var e2 = new t3().assign(n3);
    return "boolean" == typeof n3.sort && n3.sort && e2.assign({ sort: { multiColumn: true } }), e2.assign({ header: Kt.createFromConfig(e2) }), e2.assign({ storage: Qt.createFromConfig(e2) }), e2.assign({ pipeline: ln.createFromConfig(e2) }), e2.assign({ translator: new Lt(e2.language) }), e2.plugin = new $t(), e2.search && e2.plugin.add({ id: "search", position: zt.Header, component: Dt }), e2.pagination && e2.plugin.add({ id: "pagination", position: zt.Footer, component: Rt }), e2.plugins && e2.plugins.forEach(function(t4) {
      return e2.plugin.add(t4);
    }), e2;
  }, t3;
})();
function dn2(t3) {
  var n2, r2 = It();
  return w("td", e({ role: t3.role, colSpan: t3.colSpan, "data-column-id": t3.column && t3.column.id, className: rt(et("td"), t3.className, r2.className.td), style: e({}, t3.style, r2.style.td), onClick: function(n3) {
    t3.messageCell || r2.eventEmitter.emit("cellClick", n3, t3.cell, t3.column, t3.row);
  } }, (n2 = t3.column) ? "function" == typeof n2.attributes ? n2.attributes(t3.cell.data, t3.row, t3.column) : n2.attributes : {}), t3.column && "function" == typeof t3.column.formatter ? t3.column.formatter(t3.cell.data, t3.row, t3.column) : t3.column && t3.column.plugin ? w(Gt, { pluginId: t3.column.id, props: { column: t3.column, cell: t3.cell, row: t3.row } }) : t3.cell.data);
}
function hn(t3) {
  var n2 = It(), e2 = jt(function(t4) {
    return t4.header;
  });
  return w("tr", { className: rt(et("tr"), n2.className.tr), onClick: function(e3) {
    t3.messageRow || n2.eventEmitter.emit("rowClick", e3, t3.row);
  } }, t3.children ? t3.children : t3.row.cells.map(function(n3, r2) {
    var o2 = (function(t4) {
      if (e2) {
        var n4 = Kt.leafColumns(e2.columns);
        if (n4) return n4[t4];
      }
      return null;
    })(r2);
    return o2 && o2.hidden ? null : w(dn2, { key: n3.id, cell: n3, row: t3.row, column: o2 });
  }));
}
function _n(t3) {
  return w(hn, { messageRow: true }, w(dn2, { role: "alert", colSpan: t3.colSpan, messageCell: true, cell: new X(t3.message), className: rt(et("message"), t3.className ? t3.className : null) }));
}
function mn() {
  var t3 = It(), n2 = jt(function(t4) {
    return t4.data;
  }), e2 = jt(function(t4) {
    return t4.status;
  }), r2 = jt(function(t4) {
    return t4.header;
  }), o2 = At(), i2 = function() {
    return r2 ? r2.visibleColumns.length : 0;
  };
  return w("tbody", { className: rt(et("tbody"), t3.className.tbody) }, n2 && n2.rows.map(function(t4) {
    return w(hn, { key: t4.id, row: t4 });
  }), e2 === a.Loading && (!n2 || 0 === n2.length) && w(_n, { message: o2("loading"), colSpan: i2(), className: rt(et("loading"), t3.className.loading) }), e2 === a.Rendered && n2 && 0 === n2.length && w(_n, { message: o2("noRecordsFound"), colSpan: i2(), className: rt(et("notfound"), t3.className.notfound) }), e2 === a.Error && w(_n, { message: o2("error"), colSpan: i2(), className: rt(et("error"), t3.className.error) }));
}
var vn = /* @__PURE__ */ (function(t3) {
  function e2() {
    return t3.apply(this, arguments) || this;
  }
  r(e2, t3);
  var o2 = e2.prototype;
  return o2.validateProps = function() {
    for (var t4, n2 = s(this.props.columns); !(t4 = n2()).done; ) {
      var e3 = t4.value;
      void 0 === e3.direction && (e3.direction = 1), 1 !== e3.direction && -1 !== e3.direction && Vt.error("Invalid sort direction " + e3.direction);
    }
  }, o2.compare = function(t4, n2) {
    return t4 > n2 ? 1 : t4 < n2 ? -1 : 0;
  }, o2.compareWrapper = function(t4, n2) {
    for (var e3, r2 = 0, o3 = s(this.props.columns); !(e3 = o3()).done; ) {
      var i2 = e3.value;
      if (0 !== r2) break;
      var u2 = t4.cells[i2.index].data, a2 = n2.cells[i2.index].data;
      r2 |= "function" == typeof i2.compare ? i2.compare(u2, a2) * i2.direction : this.compare(u2, a2) * i2.direction;
    }
    return r2;
  }, o2._process = function(t4) {
    var n2 = [].concat(t4.rows);
    n2.sort(this.compareWrapper.bind(this));
    var e3 = new J(n2);
    return e3.length = t4.length, e3;
  }, n(e2, [{ key: "type", get: function() {
    return K.Sort;
  } }]), e2;
})(tt);
var yn = function(t3, n2, r2, o2) {
  return function(i2) {
    var u2, s2 = null != (u2 = i2.sort) && u2.columns ? i2.sort.columns.map(function(t4) {
      return e({}, t4);
    }) : [], a2 = s2.length, l2 = s2.find(function(n3) {
      return n3.index === t3;
    }), c2 = false, f2 = false, p2 = false, d2 = false;
    if (void 0 !== l2 ? r2 ? -1 === l2.direction ? p2 = true : d2 = true : 1 === a2 ? d2 = true : a2 > 1 && (f2 = true, c2 = true) : 0 === a2 ? c2 = true : a2 > 0 && !r2 ? (c2 = true, f2 = true) : a2 > 0 && r2 && (c2 = true), f2 && (s2 = []), c2) s2.push({ index: t3, direction: n2, compare: o2 });
    else if (d2) {
      var h3 = s2.indexOf(l2);
      s2[h3].direction = n2;
    } else if (p2) {
      var _2 = s2.indexOf(l2);
      s2.splice(_2, 1);
    }
    return e({}, i2, { sort: { columns: s2 } });
  };
};
var gn = function(t3, n2, r2) {
  return function(o2) {
    var i2 = (o2.sort ? [].concat(o2.sort.columns) : []).find(function(n3) {
      return n3.index === t3;
    });
    return e({}, o2, i2 ? yn(t3, 1 === i2.direction ? -1 : 1, n2, r2)(o2) : yn(t3, 1, n2, r2)(o2));
  };
};
var bn2 = /* @__PURE__ */ (function(t3) {
  function o2() {
    return t3.apply(this, arguments) || this;
  }
  return r(o2, t3), o2.prototype._process = function(t4) {
    var n2 = {};
    return this.props.url && (n2.url = this.props.url(t4.url, this.props.columns)), this.props.body && (n2.body = this.props.body(t4.body, this.props.columns)), e({}, t4, n2);
  }, n(o2, [{ key: "type", get: function() {
    return K.ServerSort;
  } }]), o2;
})(tt);
function wn(t3) {
  var n2 = It(), r2 = Ht().dispatch, o2 = At(), i2 = yt(0), u2 = i2[0], s2 = i2[1], a2 = n2.sort, l2 = jt(function(t4) {
    return t4.sort;
  }), c2 = "object" == typeof (null == a2 ? void 0 : a2.server) ? K.ServerSort : K.Sort, f2 = function() {
    var t4 = n2.pipeline.getStepsByType(c2);
    if (t4.length) return t4[0];
  };
  return gt(function() {
    var t4 = f2() || (c2 === K.ServerSort ? new bn2(e({ columns: l2 ? l2.columns : [] }, a2.server)) : new vn({ columns: l2 ? l2.columns : [] }));
    return n2.pipeline.tryRegister(t4), function() {
      return n2.pipeline.unregister(t4);
    };
  }, [n2]), gt(function() {
    if (l2) {
      var n3, e2 = l2.columns.find(function(n4) {
        return n4.index === t3.index;
      });
      e2 ? (0 === u2 && (e2.direction = null != (n3 = t3.direction) ? n3 : 1), s2(e2.direction)) : s2(0);
    }
  }, [l2]), gt(function() {
    var t4 = f2();
    t4 && l2 && t4.setProps({ columns: l2.columns });
  }, [l2]), w("button", { tabIndex: -1, "aria-label": o2("sort.sort" + (1 === u2 ? "Desc" : "Asc")), title: o2("sort.sort" + (1 === u2 ? "Desc" : "Asc")), className: rt(et("sort"), et("sort", /* @__PURE__ */ (function(t4) {
    return 1 === t4 ? "asc" : -1 === t4 ? "desc" : "neutral";
  })(u2)), n2.className.sort), onClick: function(n3) {
    n3.preventDefault(), n3.stopPropagation(), r2(gn(t3.index, true === n3.shiftKey && a2.multiColumn, t3.compare));
  } });
}
var xn = function(t3, n2) {
  var e2;
  void 0 === n2 && (n2 = 100);
  var r2 = Date.now(), o2 = function() {
    r2 = Date.now(), t3.apply(void 0, [].slice.call(arguments));
  };
  return function() {
    var t4 = [].slice.call(arguments), i2 = Date.now(), u2 = i2 - r2;
    u2 >= n2 ? o2.apply(void 0, t4) : (e2 && clearTimeout(e2), e2 = setTimeout(function() {
      o2.apply(void 0, t4), e2 = null;
    }, n2 - u2));
  };
};
function kn(t3) {
  var n2, e2 = function(t4) {
    return t4 instanceof MouseEvent ? Math.floor(t4.pageX) : Math.floor(t4.changedTouches[0].pageX);
  }, r2 = function(r3) {
    r3.stopPropagation();
    var u2 = parseInt(t3.thRef.current.style.width, 10) - e2(r3);
    n2 = xn(function(t4) {
      return o2(t4, u2);
    }, 10), document.addEventListener("mouseup", i2), document.addEventListener("touchend", i2), document.addEventListener("mousemove", n2), document.addEventListener("touchmove", n2);
  }, o2 = function(n3, r3) {
    n3.stopPropagation();
    var o3 = t3.thRef.current;
    r3 + e2(n3) >= parseInt(o3.style.minWidth, 10) && (o3.style.width = r3 + e2(n3) + "px");
  }, i2 = function t4(e3) {
    e3.stopPropagation(), document.removeEventListener("mouseup", t4), document.removeEventListener("mousemove", n2), document.removeEventListener("touchmove", n2), document.removeEventListener("touchend", t4);
  };
  return w("div", { className: rt(et("th"), et("resizable")), onMouseDown: r2, onTouchStart: r2, onClick: function(t4) {
    return t4.stopPropagation();
  } });
}
function Sn(t3) {
  var n2 = It(), r2 = bt(null), o2 = yt({}), i2 = o2[0], u2 = o2[1], s2 = Ht().dispatch;
  gt(function() {
    if (n2.fixedHeader && r2.current) {
      var t4 = r2.current.offsetTop;
      "number" == typeof t4 && u2({ top: t4 });
    }
  }, [r2]);
  var a2, l2 = function() {
    return null != t3.column.sort;
  }, c2 = function(e2) {
    e2.stopPropagation(), l2() && s2(gn(t3.index, true === e2.shiftKey && n2.sort.multiColumn, t3.column.sort.compare));
  };
  return w("th", e({ ref: r2, "data-column-id": t3.column && t3.column.id, className: rt(et("th"), l2() ? et("th", "sort") : null, n2.fixedHeader ? et("th", "fixed") : null, n2.className.th), onClick: c2, style: e({}, n2.style.th, { minWidth: t3.column.minWidth, width: t3.column.width }, i2, t3.style), onKeyDown: function(t4) {
    l2() && 13 === t4.which && c2(t4);
  }, rowSpan: t3.rowSpan > 1 ? t3.rowSpan : void 0, colSpan: t3.colSpan > 1 ? t3.colSpan : void 0 }, (a2 = t3.column) ? "function" == typeof a2.attributes ? a2.attributes(null, null, t3.column) : a2.attributes : {}, l2() ? { tabIndex: 0 } : {}), w("div", { className: et("th", "content") }, void 0 !== t3.column.name ? t3.column.name : void 0 !== t3.column.plugin ? w(Gt, { pluginId: t3.column.plugin.id, props: { column: t3.column } }) : null), l2() && w(wn, e({ index: t3.index }, t3.column.sort)), t3.column.resizable && t3.index < n2.header.visibleColumns.length - 1 && w(kn, { column: t3.column, thRef: r2 }));
}
function Nn() {
  var t3, n2 = It(), e2 = jt(function(t4) {
    return t4.header;
  });
  return e2 ? w("thead", { key: e2.id, className: rt(et("thead"), n2.className.thead) }, (t3 = Kt.tabularFormat(e2.columns)).map(function(n3, r2) {
    return (function(t4, n4, r3) {
      var o2 = Kt.leafColumns(e2.columns);
      return w(hn, null, t4.map(function(t5) {
        return t5.hidden ? null : (function(t6, n5, e3, r4) {
          var o3 = (function(t7, n6, e4) {
            var r5 = Kt.maximumDepth(t7), o4 = e4 - n6;
            return { rowSpan: Math.floor(o4 - r5 - r5 / o4), colSpan: t7.columns && t7.columns.length || 1 };
          })(t6, n5, r4);
          return w(Sn, { column: t6, index: e3, colSpan: o3.colSpan, rowSpan: o3.rowSpan });
        })(t5, n4, o2.indexOf(t5), r3);
      }));
    })(n3, r2, t3.length);
  })) : null;
}
var Pn = function(t3) {
  return function(n2) {
    return e({}, n2, { header: t3 });
  };
};
function Cn() {
  var t3 = It(), n2 = bt(null), r2 = Ht().dispatch;
  return gt(function() {
    n2 && r2(/* @__PURE__ */ (function(t4) {
      return function(n3) {
        return e({}, n3, { tableRef: t4 });
      };
    })(n2));
  }, [n2]), w("table", { ref: n2, role: "grid", className: rt(et("table"), t3.className.table), style: e({}, t3.style.table, { height: t3.height }) }, w(Nn, null), w(mn, null));
}
function En() {
  var t3 = yt(true), n2 = t3[0], r2 = t3[1], o2 = bt(null), i2 = It();
  return gt(function() {
    0 === o2.current.children.length && r2(false);
  }, [o2]), n2 ? w("div", { ref: o2, className: rt(et("head"), i2.className.header), style: e({}, i2.style.header) }, w(Gt, { position: zt.Header })) : null;
}
function In() {
  var t3 = bt(null), n2 = yt(true), r2 = n2[0], o2 = n2[1], i2 = It();
  return gt(function() {
    0 === t3.current.children.length && o2(false);
  }, [t3]), r2 ? w("div", { ref: t3, className: rt(et("footer"), i2.className.footer), style: e({}, i2.style.footer) }, w(Gt, { position: zt.Footer })) : null;
}
function Tn() {
  var t3 = It(), n2 = Ht().dispatch, r2 = jt(function(t4) {
    return t4.status;
  }), o2 = jt(function(t4) {
    return t4.data;
  }), i2 = jt(function(t4) {
    return t4.tableRef;
  }), u2 = { current: null }, s2 = xn(function() {
    try {
      n2(function(t4) {
        return e({}, t4, { status: a.Loading });
      });
      var r3 = (function(r4, o3) {
        try {
          var i3 = Promise.resolve(t3.pipeline.process()).then(function(t4) {
            n2(/* @__PURE__ */ (function(t5) {
              return function(n3) {
                return t5 ? e({}, n3, { data: t5, status: a.Loaded }) : n3;
              };
            })(t4)), setTimeout(function() {
              n2(function(t5) {
                return t5.status === a.Loaded ? e({}, t5, { status: a.Rendered }) : t5;
              });
            }, 0);
          });
        } catch (t4) {
          return o3(t4);
        }
        return i3 && i3.then ? i3.then(void 0, o3) : i3;
      })(0, function(t4) {
        Vt.error(t4), n2(function(t5) {
          return e({}, t5, { data: null, status: a.Error });
        });
      });
      return Promise.resolve(r3 && r3.then ? r3.then(function() {
      }) : void 0);
    } catch (t4) {
      return Promise.reject(t4);
    }
  }, t3.processingThrottleMs);
  return gt(function() {
    return n2(Pn(t3.header)), s2(), t3.pipeline.on("updated", s2), function() {
      return t3.pipeline.off("updated", s2);
    };
  }, []), gt(function() {
    t3.header && r2 === a.Loaded && null != o2 && o2.length && n2(Pn(t3.header.adjustWidth(t3, i2, u2)));
  }, [o2, t3, u2]), w("div", { role: "complementary", className: rt("gridjs", et("container"), r2 === a.Loading ? et("loading") : null, t3.className.container), style: e({}, t3.style.container, { width: t3.width }) }, r2 === a.Loading && w("div", { className: et("loading-bar") }), w(En, null), w("div", { className: et("wrapper"), style: { height: t3.height } }, w(Cn, null)), w(In, null), w("div", { ref: u2, id: "gridjs-temp", className: et("temp") }));
}
var Ln = /* @__PURE__ */ (function(t3) {
  function n2(n3) {
    var e3;
    return (e3 = t3.call(this) || this).config = void 0, e3.plugin = void 0, e3.config = new pn().assign({ instance: i(e3), eventEmitter: i(e3) }).update(n3), e3.plugin = e3.config.plugin, e3;
  }
  r(n2, t3);
  var e2 = n2.prototype;
  return e2.updateConfig = function(t4) {
    return this.config.update(t4), this;
  }, e2.createElement = function() {
    return w(fn.Provider, { value: this.config, children: w(Tn, {}) });
  }, e2.forceRender = function() {
    return this.config && this.config.container || Vt.error("Container is empty. Make sure you call render() before forceRender()", true), this.destroy(), q(this.createElement(), this.config.container), this;
  }, e2.destroy = function() {
    this.config.pipeline.clearCache(), q(null, this.config.container);
  }, e2.render = function(t4) {
    return t4 || Vt.error("Container element cannot be null", true), t4.childNodes.length > 0 ? (Vt.error("The container element " + t4 + " is not empty. Make sure the container is empty and call render() again"), this) : (this.config.container = t4, q(this.createElement(), t4), this);
  }, n2;
})(Q);

// src/ui/obsidian-ui-components/content-container/settings-page/statistics-page/note-stats-component.tsx
var NoteStatsComponent = class extends SettingsItemOverrideComponent {
  constructor(parentContainerEl, noteEases) {
    super(parentContainerEl);
    this.containerEl.id = "noteStats";
    const rowsPerPage = 10;
    this.noteStatsGrid = new Ln({
      columns: [
        {
          name: t("NOTE")
        },
        {
          name: t("EASE"),
          sort: true,
          width: "110px"
        }
      ],
      search: true,
      autoWidth: false,
      data: Object.entries(noteEases).sort((a2, b2) => b2[1] - a2[1]),
      pagination: Object.entries(noteEases).length > rowsPerPage ? {
        limit: rowsPerPage,
        summary: false
      } : void 0,
      language: {
        search: {
          placeholder: t("SEARCH")
        },
        pagination: {
          previous: "<",
          next: ">"
        }
      }
    });
    this.noteStatsGrid.render(this.containerEl);
  }
  /**
   * Destroys the NoteStatsComponent and its Grid.
   */
  destroy() {
    if (this.noteStatsGrid) this.noteStatsGrid.destroy();
    this.containerEl.empty();
  }
};

// src/utils/types.ts
function getTypedObjectEntries(obj) {
  return Object.entries(obj);
}
var getKeysPreserveType = Object.keys;
function mapRecord(record, transform) {
  return Object.fromEntries(
    Object.entries(record).map(([key, value]) => transform(key, value))
  );
}

// src/ui/obsidian-ui-components/content-container/settings-page/statistics-page/statistics-page.tsx
Chart.register(
  BarElement,
  BarController,
  plugin_legend,
  plugin_title,
  plugin_tooltip,
  plugin_subtitle,
  CategoryScale,
  LinearScale,
  PieController,
  ArcElement
);
var StatisticsPage = class extends SettingsPage {
  constructor(pageContainerEl, plugin, settingsManager, dataManager, pageType, openPage, scrollListener) {
    super(
      pageContainerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      () => {
      },
      () => {
      },
      openPage,
      scrollListener
    );
    this.forecastChart = null;
    this.intervalsChart = null;
    this.easesChart = null;
    this.cardTypesChart = null;
    this.noteStatsGrid = null;
    this.containerEl.addClass("sr-statistics-page");
    this.plugin = plugin;
  }
  render() {
    this.destroyCharts();
    void this.renderCharts();
  }
  /**
   * Destroys the StatisticsPagea and all its components.
   */
  destroy() {
    this.destroyCharts();
    this.containerEl.removeEventListener("scroll", (_2) => {
      this.scrollListener(this.containerEl.scrollTop);
    });
  }
  destroyCharts() {
    if (this.forecastChart !== null) this.forecastChart.destroy();
    if (this.intervalsChart !== null) this.intervalsChart.destroy();
    if (this.easesChart !== null) this.easesChart.destroy();
    if (this.cardTypesChart !== null) this.cardTypesChart.destroy();
    if (this.noteStatsGrid !== null) this.noteStatsGrid.destroy();
    this.forecastChart = null;
    this.intervalsChart = null;
    this.easesChart = null;
    this.cardTypesChart = null;
    this.noteStatsGrid = null;
    this.containerEl.empty();
  }
  async renderCharts() {
    await this.dataManager.sync();
    const cardStats = this.dataManager.osrCore.cardStats;
    if (cardStats === null) {
      return;
    }
    let maxN = cardStats.delayedDays.getMaxValue();
    for (let dueOffset = 0; dueOffset <= maxN; dueOffset++) {
      cardStats.delayedDays.clearCountIfMissing(dueOffset);
    }
    const dueDatesFlashcardsCopy = { 0: 0 };
    for (const [dueOffset, dueCount] of getTypedObjectEntries(cardStats.delayedDays.dict)) {
      if (dueOffset <= 0) {
        dueDatesFlashcardsCopy[0] += dueCount;
      } else {
        dueDatesFlashcardsCopy[dueOffset] = dueCount;
      }
    }
    const scheduledCount = cardStats.youngCount + cardStats.matureCount;
    maxN = Math.max(maxN, 1);
    new import_obsidian26.Setting(this.containerEl).setName(t("PERIOD_TITLE")).setDesc(t("PERIOD_DESC")).addDropdown((el) => {
      el.addOption("month", t("MONTH")).addOption("quarter", t("QUARTER")).addOption("year", t("YEAR")).addOption("lifetime", t("LIFETIME")).setValue("month");
      el.selectEl.setAttr("id", "sr-chart-period");
    });
    new import_obsidian26.SettingGroup(this.containerEl).setHeading(t("FORECAST")).addSetting((setting) => {
      this.forecastChart = new ChartComponent(
        setting.settingEl,
        "forecastChart",
        "forecastChartSummary",
        "bar",
        "",
        t("FORECAST_DESC"),
        Object.keys(dueDatesFlashcardsCopy),
        Object.values(dueDatesFlashcardsCopy),
        t("REVIEWS_PER_DAY", { avg: (scheduledCount / maxN).toFixed(1) }),
        t("SCHEDULED"),
        t("DAYS"),
        t("NUMBER_OF_CARDS")
      );
    });
    maxN = cardStats.intervals.getMaxValue();
    for (let interval = 0; interval <= maxN; interval++) {
      cardStats.intervals.clearCountIfMissing(interval);
    }
    const averageInterval = textInterval(
      Math.round(cardStats.intervals.getTotalOfValueMultiplyCount() / scheduledCount * 10) / 10 || 0,
      false
    );
    const longestInterval = textInterval(cardStats.intervals.getMaxValue(), false);
    new import_obsidian26.SettingGroup(this.containerEl).setHeading(t("INTERVALS")).addSetting((setting) => {
      this.intervalsChart = new ChartComponent(
        setting.settingEl,
        "intervalsChart",
        "intervalsChartSummary",
        "bar",
        "",
        t("INTERVALS_DESC"),
        Object.keys(cardStats.intervals.dict),
        Object.values(cardStats.intervals.dict),
        t("INTERVALS_SUMMARY", { avg: averageInterval, longest: longestInterval }),
        t("COUNT"),
        t("DAYS"),
        t("NUMBER_OF_CARDS")
      );
    });
    const eases = getKeysPreserveType(cardStats.eases.dict);
    for (let ease = Math.min(...eases); ease <= Math.max(...eases); ease++) {
      cardStats.eases.clearCountIfMissing(ease);
    }
    const averageEase = Math.round(cardStats.eases.getTotalOfValueMultiplyCount() / scheduledCount) || 0;
    new import_obsidian26.SettingGroup(this.containerEl).setHeading(t("EASES")).addSetting((setting) => {
      this.easesChart = new ChartComponent(
        setting.settingEl,
        "easesChart",
        "easesChartSummary",
        "bar",
        "",
        "",
        Object.keys(cardStats.eases.dict),
        Object.values(cardStats.eases.dict),
        t("EASES_SUMMARY", { avgEase: averageEase }),
        t("COUNT"),
        t("EASES"),
        t("NUMBER_OF_CARDS")
      );
    });
    const totalCardsCount = this.dataManager.osrCore.reviewableDeckTree.getDistinctRepItemCount(
      2 /* AnyItem */,
      true
    );
    new import_obsidian26.SettingGroup(this.containerEl).setHeading(t("CARD_TYPES")).addSetting((setting) => {
      this.cardTypesChart = new ChartComponent(
        setting.settingEl,
        "cardTypesChart",
        "cardTypesChartSummary",
        "pie",
        "",
        t("CARD_TYPES_DESC"),
        [
          `${t("CARD_TYPE_NEW")} - ${Math.round(cardStats.newCount / totalCardsCount * 100)}%`,
          `${t("CARD_TYPE_YOUNG")} - ${Math.round(
            cardStats.youngCount / totalCardsCount * 100
          )}%`,
          `${t("CARD_TYPE_MATURE")} - ${Math.round(
            cardStats.matureCount / totalCardsCount * 100
          )}%`
        ],
        [cardStats.newCount, cardStats.youngCount, cardStats.matureCount],
        t("CARD_TYPES_SUMMARY", { totalCardsCount })
      );
    });
    const noteEases = mapRecord(
      SRAlgorithm.getInstance().noteStats().dict,
      (key, value) => {
        return [key.split(".")[0], Math.round(value)];
      }
    );
    new import_obsidian26.SettingGroup(this.containerEl).setHeading(t("NOTES")).addSetting((setting) => {
      this.noteStatsGrid = new NoteStatsComponent(setting.settingEl, noteEases);
    });
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/ui-preferences-page.tsx
var import_obsidian27 = require("obsidian");
var UIPreferencesPage = class extends SettingsPage {
  constructor(containerEl, plugin, settingsManager, dataManager, uiManager, pageType, applySettingsUpdate, display, openPage, scrollListener) {
    super(
      containerEl,
      plugin,
      settingsManager,
      dataManager,
      pageType,
      applySettingsUpdate,
      display,
      openPage,
      scrollListener
    );
    this.uiManager = uiManager;
    new import_obsidian27.SettingGroup(this.containerEl).setHeading(t("OBSIDIAN_INTEGRATION")).addSetting((setting) => {
      setting.setName(t("OPEN_IN_TAB")).setDesc(t("OPEN_IN_TAB_DESC")).addToggle((toggle) => {
        const isMobile = import_obsidian27.Platform.isMobile || EmulatedPlatform().isMobile;
        toggle.setValue(
          isMobile ? this.settingsManager.settings.openViewInNewTabMobile : this.settingsManager.settings.openViewInNewTab
        ).onChange(async (value) => {
          if (isMobile) {
            this.settingsManager.settings.openViewInNewTabMobile = value;
            this.settingsManager.settings.flashcardHeightPercentageMobile = 100;
            this.settingsManager.settings.flashcardWidthPercentageMobile = 100;
          } else {
            this.settingsManager.settings.openViewInNewTab = value;
            this.settingsManager.settings.flashcardHeightPercentage = 100;
            this.settingsManager.settings.flashcardWidthPercentage = 100;
          }
          if (value) {
            this.uiManager.registerSRFocusListener();
          } else {
            this.uiManager.tabViewManager.closeAllTabViews();
            this.settingsManager.settings.useCustomHotkeys = false;
            this.uiManager.removeSRFocusListener();
          }
          await this.settingsManager.save();
          this.display();
        });
      });
    }).addSetting((setting) => {
      const isMobile = import_obsidian27.Platform.isMobile || EmulatedPlatform().isMobile;
      setting.setName(t("USE_CUSTOM_HOTKEYS")).setDesc(t("USE_CUSTOM_HOTKEYS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.useCustomHotkeys).setDisabled(
          isMobile && !this.settingsManager.settings.openViewInNewTabMobile || !isMobile && !this.settingsManager.settings.openViewInNewTab
        ).onChange(async (value) => {
          this.settingsManager.settings.useCustomHotkeys = value;
          if (this.settingsManager.settings.useCustomHotkeys) {
            this.plugin.commandManager.addCustomHotkeys();
          } else {
            this.plugin.commandManager.removeCustomHotkeys();
          }
          this.plugin.commandManager.addCustomHotkeys();
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_RIBBON_ICON")).setDesc(t("SHOW_RIBBON_ICON_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showRibbonIcon).onChange(async (value) => {
          this.settingsManager.settings.showRibbonIcon = value;
          await this.settingsManager.save();
          this.uiManager.showRibbonIcon(value);
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("ENABLE_FILE_MENU_REVIEW_OPTIONS")).setDesc(t("ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showFileMenuReviewOptions).onChange(async (value) => {
          this.settingsManager.settings.showFileMenuReviewOptions = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("ENABLE_FILE_MENU_DELETE_BUTTON")).setDesc(t("ENABLE_FILE_MENU_DELETE_BUTTON_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showDeleteButtonInFileMenu).onChange(async (value) => {
          this.settingsManager.settings.showDeleteButtonInFileMenu = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_DELETE_BUTTON")).setDesc(t("SHOW_DELETE_BUTTON_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showDeleteButtonInCardView).onChange(async (value) => {
          this.settingsManager.settings.showDeleteButtonInCardView = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("CARD_MODAL_HEIGHT_PERCENT")).setDesc(t("CARD_MODAL_SIZE_PERCENT_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          const isMobile = import_obsidian27.Platform.isMobile || EmulatedPlatform().isMobile;
          if (isMobile) {
            this.settingsManager.settings.flashcardHeightPercentageMobile = DEFAULT_SETTINGS.flashcardHeightPercentageMobile;
          } else {
            this.settingsManager.settings.flashcardHeightPercentage = DEFAULT_SETTINGS.flashcardHeightPercentage;
          }
          await this.settingsManager.save();
          this.display();
        });
      }).addSlider((slider) => {
        const isMobile = import_obsidian27.Platform.isMobile || EmulatedPlatform().isMobile;
        slider.setLimits(10, 100, 5).setValue(
          isMobile ? this.settingsManager.settings.flashcardHeightPercentageMobile : this.settingsManager.settings.flashcardHeightPercentage
        ).setDynamicTooltip().onChange(async (value) => {
          if (isMobile) {
            this.settingsManager.settings.flashcardHeightPercentageMobile = value;
          } else {
            this.settingsManager.settings.flashcardHeightPercentage = value;
          }
          await this.settingsManager.save();
        });
      });
    }).addSetting((setting) => {
      setting.setName(t("CARD_MODAL_WIDTH_PERCENT")).setDesc(t("CARD_MODAL_SIZE_PERCENT_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          const isMobile = import_obsidian27.Platform.isMobile || EmulatedPlatform().isMobile;
          if (isMobile) {
            this.settingsManager.settings.flashcardWidthPercentageMobile = DEFAULT_SETTINGS.flashcardWidthPercentageMobile;
          } else {
            this.settingsManager.settings.flashcardWidthPercentage = DEFAULT_SETTINGS.flashcardWidthPercentage;
          }
          await this.settingsManager.save();
          this.display();
        });
      }).addSlider((slider) => {
        const isMobile = import_obsidian27.Platform.isMobile || EmulatedPlatform().isMobile;
        slider.setLimits(10, 100, 5).setValue(
          isMobile ? this.settingsManager.settings.flashcardWidthPercentageMobile : this.settingsManager.settings.flashcardWidthPercentage
        ).setDynamicTooltip().onChange(async (value) => {
          if (isMobile) {
            this.settingsManager.settings.flashcardWidthPercentageMobile = value;
          } else {
            this.settingsManager.settings.flashcardWidthPercentage = value;
          }
          await this.settingsManager.save();
        });
      });
    });
    new import_obsidian27.SettingGroup(this.containerEl).setHeading(t("STATUS_BAR_SETTINGS")).addSetting((setting) => {
      setting.setName(t("SHOW_STATUS_BAR")).setDesc(t("SHOW_STATUS_BAR_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showStatusBar).onChange(async (value) => {
          this.settingsManager.settings.showStatusBar = value;
          await this.settingsManager.save();
          await this.uiManager.updateStatusBar();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_CARD_STATUS_BAR_ITEM")).setDesc(t("SHOW_CARD_STATUS_BAR_ITEM_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showCardStatusBarItem).onChange(async (value) => {
          this.settingsManager.settings.showCardStatusBarItem = value;
          await this.settingsManager.save();
          await this.uiManager.updateStatusBar();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_NOTE_STATUS_BAR_ITEM")).setDesc(t("SHOW_NOTE_STATUS_BAR_ITEM_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showNoteStatusBarItem).onChange(async (value) => {
          this.settingsManager.settings.showNoteStatusBarItem = value;
          await this.settingsManager.save();
          await this.uiManager.updateStatusBar();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_UPDATE_AVAILABLE_STATUS_BAR_ITEM")).setDesc(t("SHOW_UPDATE_AVAILABLE_STATUS_BAR_ITEM_DESC")).addToggle(
        (toggle) => toggle.setValue(
          this.settingsManager.settings.showUpdateAvailableStatusBarItem
        ).onChange(async (value) => {
          this.settingsManager.settings.showUpdateAvailableStatusBarItem = value;
          await this.settingsManager.save();
          await this.uiManager.updateStatusBar();
        })
      );
    });
    new import_obsidian27.SettingGroup(this.containerEl).setHeading(t("FLASHCARDS")).addSetting((setting) => {
      setting.setName(t("INITIALLY_EXPAND_SUBDECKS_IN_TREE")).setDesc(t("INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC")).addToggle(
        (toggle) => toggle.setValue(
          this.settingsManager.settings.initiallyExpandAllSubdecksInTree
        ).onChange(async (value) => {
          this.settingsManager.settings.initiallyExpandAllSubdecksInTree = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_CARD_CONTEXT")).setDesc(t("SHOW_CARD_CONTEXT_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showContextInCards).onChange(async (value) => {
          this.settingsManager.settings.showContextInCards = value;
          await this.settingsManager.save();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("CONVERT_CLOZE_PATTERNS_TO_INPUTS")).setDesc(t("CONVERT_CLOZE_PATTERNS_TO_INPUTS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.convertClozePatternsToInputs).onChange(async (value) => {
          this.settingsManager.settings.convertClozePatternsToInputs = value;
          await this.settingsManager.save();
          this.display();
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("SHOW_INTERVAL_IN_REVIEW_BUTTONS")).setDesc(t("SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC")).addToggle(
        (toggle) => toggle.setValue(this.settingsManager.settings.showIntervalInReviewButtons).onChange(async (value) => {
          this.settingsManager.settings.showIntervalInReviewButtons = value;
          await this.settingsManager.save();
        })
      );
    });
    new import_obsidian27.SettingGroup(this.containerEl).setHeading(t("GROUP_FLASHCARDS_NOTES")).addSetting((setting) => {
      setting.setName(t("FLASHCARD_EASY_LABEL")).setDesc(t("FLASHCARD_EASY_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.flashcardEasyText = DEFAULT_SETTINGS.flashcardEasyText;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.flashcardEasyText).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.flashcardEasyText = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("FLASHCARD_GOOD_LABEL")).setDesc(t("FLASHCARD_GOOD_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.flashcardGoodText = DEFAULT_SETTINGS.flashcardGoodText;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.flashcardGoodText).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.flashcardGoodText = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("FLASHCARD_HARD_LABEL")).setDesc(t("FLASHCARD_HARD_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.flashcardHardText = DEFAULT_SETTINGS.flashcardHardText;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.flashcardHardText).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.flashcardHardText = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("FLASHCARD_AGAIN_LABEL")).setDesc(t("FLASHCARD_AGAIN_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.flashcardAgainText = DEFAULT_SETTINGS.flashcardAgainText;
          await this.settingsManager.save();
          this.display();
        });
      }).addText(
        (text) => text.setValue(this.settingsManager.settings.flashcardAgainText).onChange((value) => {
          applySettingsUpdate(async () => {
            this.settingsManager.settings.flashcardAgainText = value;
            await this.settingsManager.save();
          });
        })
      );
    }).addSetting((setting) => {
      setting.setName(t("REVIEW_BUTTON_DELAY")).setDesc(t("REVIEW_BUTTON_DELAY_DESC")).addExtraButton((button) => {
        button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
          this.settingsManager.settings.reviewButtonDelay = DEFAULT_SETTINGS.reviewButtonDelay;
          await this.settingsManager.save();
          this.display();
        });
      }).addSlider(
        (slider) => slider.setLimits(0, 5e3, 100).setValue(this.settingsManager.settings.reviewButtonDelay).setDynamicTooltip().onChange(async (value) => {
          this.settingsManager.settings.reviewButtonDelay = value;
          await this.settingsManager.save();
        })
      );
    });
  }
};

// src/ui/obsidian-ui-components/content-container/settings-page/settings-page-manager.tsx
var SettingsPageTypesArray = [
  "main-page",
  "flashcards-page",
  "notes-page",
  "scheduling-page",
  "ui-preferences-page",
  "data-page",
  "statistics-page"
];
function getPageName(pageType) {
  switch (pageType) {
    case "main-page":
      return t("MAIN_SETTINGS_PAGE");
    case "flashcards-page":
      return t("FLASHCARDS");
    case "notes-page":
      return t("NOTES");
    case "scheduling-page":
      return t("SCHEDULING");
    case "ui-preferences-page":
      return t("UI");
    case "data-page":
      return t("DATA_PAGE_NAME");
    case "statistics-page":
      return t("STATS_TITLE");
  }
}
function getPageIcon(pageType) {
  switch (pageType) {
    case "main-page":
      return "Settings";
    case "flashcards-page":
      return "SpacedRepIcon";
    case "notes-page":
      return "book-text";
    case "scheduling-page":
      return "calendar";
    case "ui-preferences-page":
      return "presentation";
    case "data-page":
      return "hard-drive";
    case "statistics-page":
      return "bar-chart-3";
  }
}
var SettingsPageManager = class {
  constructor(containerEl, plugin, uiManager, settingsManager, lastPage, lastScrollPosition, didReadMultilineEndMarkerWarning, updateLastPageState, display, changeMultilineEndMarkerWarningState) {
    this.pages = [];
    this.applyDebounceTimer = 0;
    this.containerEl = containerEl;
    this.plugin = plugin;
    this.dataManager = plugin.dataManager;
    this.uiManager = uiManager;
    this.settingsManager = settingsManager;
    this.didReadMultilineEndMarkerWarning = didReadMultilineEndMarkerWarning;
    this.changeMultilineEndMarkerWarningState = changeMultilineEndMarkerWarningState;
    this.updateLastPageState = updateLastPageState;
    this.display = display;
    this.createPages();
    this.currentPage = lastPage;
    this.pages[this.getPageIndex(this.currentPage)].show();
    this.pages[this.getPageIndex(this.currentPage)].scrollTo(lastScrollPosition);
  }
  /**
   * Destroys the SettingsPageManager and all its pages.
   */
  destroy() {
    this.pages.forEach((page) => page.destroy && page.destroy());
  }
  /**
   * Renders the SettingsPageManager.
   */
  render() {
    this.pages.forEach((page) => page.render && page.render());
  }
  // https://github.com/mgmeyers/obsidian-kanban/blob/main/src/Settings.ts
  applySettingsUpdate(callback2) {
    window.clearTimeout(this.applyDebounceTimer);
    this.applyDebounceTimer = window.setTimeout(callback2, 512);
  }
  createPages() {
    this.containerEl.empty();
    for (const pageType of SettingsPageTypesArray) {
      const newPageContainerEl = this.containerEl.createDiv();
      switch (pageType) {
        case "main-page":
          this.pages.push(
            new MainPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              pageType,
              this.display,
              this.openPage.bind(this),
              this.scrollListener.bind(this)
            )
          );
          break;
        case "flashcards-page":
          this.pages.push(
            new FlashcardsPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              pageType,
              this.didReadMultilineEndMarkerWarning,
              this.applySettingsUpdate.bind(this),
              this.display,
              this.openPage.bind(this),
              this.scrollListener.bind(this),
              this.changeMultilineEndMarkerWarningState.bind(this)
            )
          );
          break;
        case "notes-page":
          this.pages.push(
            new NotesPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              pageType,
              this.applySettingsUpdate.bind(this),
              this.display,
              this.openPage.bind(this),
              this.scrollListener.bind(this)
            )
          );
          break;
        case "scheduling-page":
          this.pages.push(
            new SchedulingPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              pageType,
              (callback2) => {
                this.applySettingsUpdate(callback2);
              },
              this.display,
              (pageType2) => {
                this.openPage(pageType2);
              },
              this.scrollListener.bind(this)
            )
          );
          break;
        case "ui-preferences-page":
          this.pages.push(
            new UIPreferencesPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              this.uiManager,
              pageType,
              this.applySettingsUpdate.bind(this),
              this.display,
              this.openPage.bind(this),
              this.scrollListener.bind(this)
            )
          );
          break;
        case "data-page":
          this.pages.push(
            new DataPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              pageType,
              this.applySettingsUpdate.bind(this),
              this.display,
              this.openPage.bind(this),
              this.scrollListener.bind(this)
            )
          );
          break;
        case "statistics-page":
          this.pages.push(
            new StatisticsPage(
              newPageContainerEl,
              this.plugin,
              this.settingsManager,
              this.dataManager,
              pageType,
              this.openPage.bind(this),
              this.scrollListener.bind(this)
            )
          );
          break;
      }
    }
  }
  scrollListener(scrollPosition) {
    this.updateLastPageState(this.currentPage, scrollPosition);
  }
  getPageIndex(pageType) {
    return this.pages.findIndex((page) => page.getPageType() === pageType);
  }
  openPage(pageType) {
    if (this.currentPage === pageType) return;
    this.pages[this.getPageIndex(this.currentPage)].hide();
    this.currentPage = pageType;
    this.updateLastPageState(this.currentPage, 0);
    this.pages[this.getPageIndex(this.currentPage)].show();
  }
};

// src/ui/obsidian-ui-components/settings-tab.tsx
var SRSettingTab = class extends import_obsidian28.PluginSettingTab {
  constructor(app, plugin, uiManager, settingsManager) {
    super(app, plugin);
    this.settingsPageManager = null;
    this.lastPage = "main-page";
    this.lastScrollPosition = 0;
    this.didReadMultilineEndMarkerWarning = false;
    this.plugin = plugin;
    this.uiManager = uiManager;
    this.settingsManager = settingsManager;
    this.icon = "SpacedRepIcon";
    this.containerEl.addClass("sr-settings-tab");
  }
  display() {
    this.containerEl.empty();
    this.settingsPageManager = new SettingsPageManager(
      this.containerEl,
      this.plugin,
      this.uiManager,
      this.settingsManager,
      this.lastPage,
      this.lastScrollPosition,
      this.didReadMultilineEndMarkerWarning,
      (lastPage, lastScrollPosition) => {
        this.lastPage = lastPage;
        this.lastScrollPosition = lastScrollPosition;
      },
      () => {
        this.display();
      },
      (state) => {
        this.didReadMultilineEndMarkerWarning = state;
        this.display();
      }
    );
  }
  hide() {
    if (this.settingsPageManager) this.settingsPageManager.destroy();
    this.containerEl.empty();
  }
};

// src/data/data-structures/card/card.ts
var Card = class extends RepetitionItem {
  constructor(init) {
    super("Card" /* Card */, 0 /* New */, null, null);
    // visuals
    this.front = "";
    this.back = "";
    Object.assign(this, init);
  }
  formatSchedule() {
    return this.scheduleInfo !== null ? this.scheduleInfo.formatScheduleAsSRHtmlComment() : "New";
  }
  toString() {
    return `${this.front}::${this.back}`;
  }
};

// src/data/data-structures/deck/deck.ts
var Deck = class _Deck {
  constructor(deckName, parent) {
    this.deckName = deckName;
    this.newRepItems = [];
    this.dueRepItems = [];
    this.subdecks = [];
    this.parent = parent;
  }
  /**
   * Gets the number of repetition items of the specified type in this deck and all its subdecks.
   *
   * @param {RepItemState} repItemListType - The repetition item list type.
   * @param {boolean} includeSubdeckCounts - Whether to include the count of repetition items in subdecks.
   * @returns {number} - The number of repetition items of the specified type in this deck and all its subdecks.
   */
  getRepItemCount(repItemListType, includeSubdeckCounts) {
    let result = 0;
    if (repItemListType === 0 /* NewItem */ || repItemListType === 2 /* AnyItem */)
      result += this.newRepItems.length;
    if (repItemListType === 1 /* DueItem */ || repItemListType === 2 /* AnyItem */)
      result += this.dueRepItems.length;
    if (includeSubdeckCounts) {
      for (const deck of this.subdecks) {
        result += deck.getRepItemCount(repItemListType, includeSubdeckCounts);
      }
    }
    return result;
  }
  /**
   * Gets the number of distinct repetition items of the specified type in this deck and all its subdecks.
   *
   * @param {RepItemState} repItemListType - The repetition item list type.
   * @param {boolean} includeSubdeckCounts - Whether to include the count of repetition items in subdecks.
   * @returns {number} - The number of distinct repetition items of the specified type in this deck and all its subdecks.
   */
  getDistinctRepItemCount(repItemListType, includeSubdeckCounts) {
    const repItemList = this.getFlattenedRepItemArray(
      repItemListType,
      includeSubdeckCounts
    );
    const distinctCardSet = new Set(repItemList);
    return distinctCardSet.size;
  }
  /**
   * Gets an array of repetition items of the specified type in this deck and all its subdecks.
   *
   * @param {RepItemState} repItemListType - The repetition item list type.
   * @param {boolean} includeSubdeckCounts - Whether to include the count of repetition items in subdecks.
   * @returns {RepetitionItem[]} - An array of repetition items of the specified type in this deck and all its subdecks.
   */
  getFlattenedRepItemArray(repItemListType, includeSubdeckCounts) {
    let result = [];
    switch (repItemListType) {
      case 0 /* NewItem */:
        result = this.newRepItems;
        break;
      case 1 /* DueItem */:
        result = this.dueRepItems;
        break;
      case 2 /* AnyItem */:
        result = this.newRepItems.concat(this.dueRepItems);
    }
    if (includeSubdeckCounts) {
      for (const subdeck of this.subdecks) {
        result = result.concat(
          subdeck.getFlattenedRepItemArray(repItemListType, includeSubdeckCounts)
        );
      }
    }
    return result;
  }
  // Returns a count of the number of this question's repetition items are present in this deck.
  // (The returned value would be <= question.cards.length)
  getQuestionRepItemCount(question) {
    let result = 0;
    result += this.getQuestionRepItemCountForRepItemListType(question, this.newRepItems);
    result += this.getQuestionRepItemCountForRepItemListType(question, this.dueRepItems);
    return result;
  }
  /**
   * Gets the number of repetition items of the specified type in the specified question.
   *
   * @param {Question} question - The question.
   * @param {RepetitionItem[]} repItems - The repetition items.
   * @returns {number} - The number of repetition items of the specified type in the specified question.
   */
  getQuestionRepItemCountForRepItemListType(question, repItems) {
    let result = 0;
    for (let i2 = 0; i2 < repItems.length; i2++) {
      if (repItems[i2] instanceof Card && Object.is(question, repItems[i2].question)) result++;
    }
    return result;
  }
  static get emptyDeck() {
    return new _Deck("Root", null);
  }
  get isRootDeck() {
    return this.parent === null;
  }
  /**
   * Gets the deck with the specified tag.
   *
   * @param {string} tag - The tag.
   * @returns {Deck | null} - The deck with the specified tag, or null if not found.
   */
  getDeckByTopicTag(tag) {
    return this.getDeck(TopicPath.getTopicPathFromTag(tag));
  }
  /**
   * Gets the deck with the specified topic path.
   *
   * @param {TopicPath} topicPath - The topic path.
   * @returns {Deck | null} - The deck with the specified topic path, or null if not found.
   */
  getDeck(topicPath) {
    return this._findDeckByTopicPath(topicPath);
  }
  /**
   * Gets or creates a deck with the specified topic path.
   *
   * @param {TopicPath} topicPath - The topic path.
   * @param {boolean} createAllowed - Whether to create the deck if it doesn't exist.
   * @returns {Deck | null} - The deck with the specified topic path, or null if it doesn't exist and createAllowed is false.
   */
  _findDeckByTopicPath(topicPath) {
    if (!topicPath.hasPath) {
      return this;
    }
    const t3 = topicPath.clone();
    const deckName = t3.shift();
    for (const subdeck of this.subdecks) {
      if (deckName === subdeck.deckName) {
        return subdeck._findDeckByTopicPath(t3);
      }
    }
    return null;
  }
  /**
   * Gets or creates a deck with the specified topic path.
   *
   * @param {TopicPath} topicPath - The topic path.
   * @returns {Deck} - The deck with the specified topic path
   */
  getOrCreateDeck(topicPath) {
    if (!topicPath.hasPath) {
      return this;
    }
    const t3 = topicPath.clone();
    const deckName = t3.shift();
    for (const subdeck2 of this.subdecks) {
      if (deckName === subdeck2.deckName) {
        return subdeck2.getOrCreateDeck(t3);
      }
    }
    const subdeck = new _Deck(
      deckName,
      this
      /* parent */
    );
    this.subdecks.push(subdeck);
    return subdeck.getOrCreateDeck(t3);
  }
  /**
   * Gets the topic path of the deck.
   *
   * @returns {TopicPath} - The topic path of the deck.
   */
  getTopicPath() {
    const list = [];
    let deck = this;
    while (!deck.isRootDeck) {
      list.push(deck.deckName);
      if (deck.parent === null) {
        break;
      }
      deck = deck.parent;
    }
    return new TopicPath(list.reverse());
  }
  /**
   * Gets the root deck of the deck.
   *
   * @returns {Deck} - The root deck of the deck.
   */
  getRootDeck() {
    let deck = this;
    while (!deck.isRootDeck) {
      if (deck.parent === null) {
        break;
      }
      deck = deck.parent;
    }
    return deck;
  }
  /**
   * Gets the RepetitionItem with the specified index.
   *
   * @param {number} index - The index of the RepetitionItem.
   * @param {RepItemState} state - The state of the RepetitionItem.
   * @returns {RepetitionItem} - The RepetitionItem with the specified index.
   */
  getRepItem(index, repItemListType) {
    const repItemList = this.getRepItemListForRepItemState(repItemListType);
    return repItemList[index];
  }
  /**
   * Gets the list of RepetitionItems for the specified state.
   *
   * @param {RepItemState} state - The state of the RepetitionItems.
   * @returns {RepetitionItem[]} - The list of RepetitionItems for the specified state.
   */
  getRepItemListForRepItemState(state) {
    return state === 1 /* DueItem */ ? this.dueRepItems : this.newRepItems;
  }
  /**
   * Appends a RepetitionItem to the deck.
   *
   * @param {TopicPathList} topicPathList - The topic path list.
   * @param {RepetitionItem} repItem - The RepetitionItem to append.
   */
  appendRepItem(topicPathList, repItem) {
    if (topicPathList.list.length === 0) {
      this.appendRepItemToRootDeck(repItem);
    } else {
      for (const topicPath of topicPathList.list) {
        this.appendRepItemSingleTopic(topicPath, repItem);
      }
    }
  }
  /**
   * Appends a RepetitionItem to the root deck.
   *
   * This is used for cards that don't have any topics, and also for postponing cards (e.g. when skipping a card, we move it to the root deck and remove its topic paths, so that it won't be seen until the next review session when we reassign it to decks based on its question's topic paths)
   *
   * @param {RepetitionItem} repItem - The RepetitionItem to append.
   */
  appendRepItemToRootDeck(repItem) {
    this.appendRepItemSingleTopic(TopicPath.emptyPath, repItem);
  }
  /**
   * Appends a RepetitionItem to a deck with the specified topic path.
   *
   * @param {TopicPath} topicPath - The topic path.
   * @param {RepetitionItem} repItem - The RepetitionItem to append.
   */
  appendRepItemSingleTopic(topicPath, repItem) {
    const deck = this.getOrCreateDeck(topicPath);
    const repItemList = deck.getRepItemListForRepItemState(
      repItem.repItemState
    );
    repItemList.push(repItem);
  }
  // The question lists all the topics in which this card is included.
  // The topics are relative to the base deck, and this method must be called on that deck
  deleteQuestionFromAllDecks(question, exceptionIfMissing) {
    for (const card of question.cards) {
      this.deleteCardFromAllDecks(card, exceptionIfMissing);
    }
  }
  deleteQuestion(question, exceptionIfMissing) {
    for (const card of question.cards) {
      this.deleteCardFromThisDeck(card, exceptionIfMissing);
    }
  }
  // The card's question lists all the topics in which this card is included.
  // The topics are relative to the base deck, and this method must be called on that deck
  deleteCardFromAllDecks(card, exceptionIfMissing) {
    for (const topicPath of card.question.topicPathList.list) {
      const deck = this.getDeck(topicPath);
      if (deck) {
        deck.deleteCardFromThisDeck(card, exceptionIfMissing);
      }
    }
  }
  deleteCardFromThisDeck(card, exceptionIfMissing) {
    const newIdx = this.newRepItems.indexOf(card);
    if (newIdx !== -1) this.newRepItems.splice(newIdx, 1);
    const dueIdx = this.dueRepItems.indexOf(card);
    if (dueIdx !== -1) this.dueRepItems.splice(dueIdx, 1);
    if (newIdx === -1 && dueIdx === -1 && exceptionIfMissing) {
      throw new Error(
        `deleteCardFromThisDeck: Card: ${card.front} not found in deck: ${this.deckName}`
      );
    }
  }
  /**
   * Deletes a RepetitionItem at the specified index.
   *
   * @param {number} index - The index of the RepetitionItem to delete.
   * @param {RepItemState} repItemState - The state of the RepetitionItem.
   */
  deleteRepItemAtIndex(index, repItemState) {
    const repItemList = this.getRepItemListForRepItemState(repItemState);
    repItemList.splice(index, 1);
  }
  /**
   * Exports the deck and all its subdecks to an array.
   *
   * @returns {Deck[]} - An array containing the deck and all its subdecks.
   */
  toDeckArray() {
    const result = [];
    result.push(this);
    for (const subdeck of this.subdecks) {
      result.push(...subdeck.toDeckArray());
    }
    return result;
  }
  /**
   * Sorts the subdecks list in ascending order by deck name.
   */
  sortSubdecksList() {
    this.subdecks.sort((a2, b2) => {
      if (a2.deckName < b2.deckName) {
        return -1;
      } else if (a2.deckName > b2.deckName) {
        return 1;
      }
      return 0;
    });
    for (const deck of this.subdecks) {
      deck.sortSubdecksList();
    }
  }
  /**
   * Logs the deck and its subdecks to the console.
   *
   * @param {string | null} desc - The description to log.
   * @param {number} indent - The indentation level.
   */
  debugLogToConsole(desc = null, indent = 0) {
    let str = desc !== null && desc !== void 0 ? `${desc}: ` : "";
    str += this.toString(indent);
    console.log(str);
  }
  /**
   * Converts the deck and its subdecks to a string.
   *
   * @param {number} indent - The indentation level.
   * @returns {string} - The string representation of the deck and its subdecks.
   */
  toString(indent = 0) {
    let result = "";
    let indentStr = " ".repeat(indent * 4);
    result += `${indentStr}${this.deckName}\r
`;
    indentStr += "  ";
    for (let i2 = 0; i2 < this.newRepItems.length; i2++) {
      const repItem = this.newRepItems[i2];
      result += `${indentStr}New: ${i2}: ${repItem.toString()}\r
`;
    }
    for (let i2 = 0; i2 < this.dueRepItems.length; i2++) {
      const repItem = this.dueRepItems[i2];
      const s2 = repItem.isDue ? "Due" : "Not due";
      result += `${indentStr}${s2}: ${i2}: ${repItem.toString()}\r
`;
    }
    for (const subdeck of this.subdecks) {
      result += subdeck.toString(indent + 1);
    }
    return result;
  }
  /**
   * Clones the deck and its subdecks.
   *
   * @returns {Deck} - The cloned deck and its subdecks.
   */
  clone() {
    return this.copyWithRepItemFilter(() => true);
  }
  /**
   * Copies the deck and its subdecks with a filter.
   *
   * @param {(value: RepetitionItem) => boolean} predicate - The filter function.
   * @param {Deck | null} parent - The parent deck.
   * @returns {Deck} - The copied deck and its subdecks with the filter applied.
   */
  copyWithRepItemFilter(predicate, parent = null) {
    const result = new _Deck(this.deckName, parent);
    result.newRepItems = [...this.newRepItems.filter((card) => predicate(card))];
    result.dueRepItems = [...this.dueRepItems.filter((card) => predicate(card))];
    for (const s2 of this.subdecks) {
      const newParent = result;
      const newDeck = s2.copyWithRepItemFilter(predicate, newParent);
      result.subdecks.push(newDeck);
    }
    return result;
  }
  /**
   * Gets the opposite state of the specified state.
   *
   * @param {RepItemState} repItemState - The state.
   * @returns {RepItemState} - The opposite state.
   */
  static otherListType(repItemState) {
    let result;
    if (repItemState === 0 /* NewItem */) result = 1 /* DueItem */;
    else if (repItemState === 1 /* DueItem */) result = 0 /* NewItem */;
    else throw new Error("Invalid repItemState");
    return result;
  }
};
var DeckTreeFilter = class {
  /**
   * Filters the deck tree for the remaining repetition items.
   *
   * @param {IQuestionPostponementList} questionPostponementList - The question postponement list.
   * @param {Deck} deckTree - The deck tree.
   * @param {FlashcardReviewMode} reviewMode - The review mode.
   * @returns {Deck} - The filtered deck tree.
   */
  static filterForRemainingRepItems(questionPostponementList, deckTree, reviewMode) {
    return deckTree.copyWithRepItemFilter(
      (repItem) => (reviewMode === 0 /* Cram */ || repItem.isNew || repItem.isDue) && !questionPostponementList.includes(repItem.question)
    );
  }
};

// src/utils/numbers.ts
var ValueCountDict = class {
  constructor() {
    this.dict = {};
  }
  // Record<value, count>
  clearCountIfMissing(value) {
    if (!this.hasValue(value)) this.dict[value] = 0;
  }
  hasValue(value) {
    return this.dict[value] !== void 0 && this.dict[value] !== null;
  }
  incrementCount(value) {
    this.clearCountIfMissing(value);
    this.dict[value]++;
  }
  getMaxValue() {
    return Math.max(...getKeysPreserveType(this.dict)) || 0;
  }
  getTotalOfValueMultiplyCount() {
    const v2 = getTypedObjectEntries(this.dict).map(([value, count]) => value * count).reduce((a2, b2) => a2 + b2, 0) || 0;
    return v2;
  }
};
var RandomNumberProvider = class {
  getInteger(lowerBound, upperBound) {
    const range2 = upperBound - lowerBound + 1;
    return Math.floor(Math.random() * range2) + lowerBound;
  }
};
var StaticRandomNumberProvider = class {
  getInteger(lowerBound, upperBound) {
    if (lowerBound !== this.expectedLowerBound || upperBound !== this.expectedUpperBound)
      return 0;
    return this.next;
  }
};
var WeightedRandomNumber = class _WeightedRandomNumber {
  constructor(provider) {
    this.provider = provider;
  }
  static create() {
    return new _WeightedRandomNumber(globalRandomNumberProvider);
  }
  // weights is a dictionary:
  //      first number - a key that can be returned
  //      second number - the "bucket size" - this is a weight that influences the probability of the
  //          first number being returned
  //
  // returns:
  //      first number - one of the keys from the weights parameter
  //      second number - an "index" value; 0 <= index < bucketSize
  getRandomValues(weights) {
    const total = _WeightedRandomNumber.calcTotalOfCount(weights);
    if (Object.values(weights).some((i2) => !Number.isInteger(i2) || i2 < 0))
      throw new Error("Weights must be positive integers");
    const v2 = this.provider.getInteger(0, total - 1);
    let x2 = 0;
    for (const kvp in weights) {
      const [value, count] = [Number(kvp), weights[kvp]];
      if (v2 < x2 + count) {
        const index = v2 - x2;
        return [value, index];
      }
      x2 += count;
    }
    throw new Error("Should not reach here if weights are valid and provider is correct");
  }
  static calcTotalOfCount(weights) {
    const total = getTypedObjectEntries(weights).map(([_2, count]) => count).reduce((a2, b2) => a2 + b2, 0) || 0;
    return total;
  }
};
var globalRandomNumberProvider = new RandomNumberProvider();
var staticRandomNumberProvider = new StaticRandomNumberProvider();

// src/data/data-structures/deck/deck-tree-iterator.ts
var RepItemOrder = /* @__PURE__ */ ((RepItemOrder2) => {
  RepItemOrder2[RepItemOrder2["NewFirstSequential"] = 0] = "NewFirstSequential";
  RepItemOrder2[RepItemOrder2["NewFirstRandom"] = 1] = "NewFirstRandom";
  RepItemOrder2[RepItemOrder2["DueFirstSequential"] = 2] = "DueFirstSequential";
  RepItemOrder2[RepItemOrder2["DueFirstRandom"] = 3] = "DueFirstRandom";
  RepItemOrder2[RepItemOrder2["EveryCardRandomDeckAndCard"] = 4] = "EveryCardRandomDeckAndCard";
  return RepItemOrder2;
})(RepItemOrder || {});
var DeckOrder = /* @__PURE__ */ ((DeckOrder2) => {
  DeckOrder2[DeckOrder2["PrevDeckComplete_Sequential"] = 0] = "PrevDeckComplete_Sequential";
  DeckOrder2[DeckOrder2["PrevDeckComplete_Random"] = 1] = "PrevDeckComplete_Random";
  return DeckOrder2;
})(DeckOrder || {});
var SingleDeckIterator = class _SingleDeckIterator {
  constructor(iteratorOrder) {
    this.deck = null;
    this.iteratorOrder = iteratorOrder;
    this.preferredCardListType = _SingleDeckIterator.getCardListTypeForIterator(
      this.iteratorOrder
    );
    this.weightedRandomNumber = WeightedRandomNumber.create();
  }
  get hasCurrentCard() {
    return this.cardIdx !== null && this.cardIdx !== void 0;
  }
  get currentCard() {
    let result = null;
    if (this.cardIdx !== null && this.cardIdx !== void 0 && this.deck !== null)
      result = this.deck.getRepItem(this.cardIdx, this.cardListType);
    return result;
  }
  setDeck(deck) {
    this.deck = deck;
    this.setCardListType(null);
  }
  //
  // 0 <= cardIndex < newFlashcards.length + dueFlashcards.length
  //
  setNewOrDueCardIdx(cardIndex) {
    let cardListType = 0 /* NewItem */;
    let index = cardIndex;
    if (cardIndex >= this.deck.newRepItems.length) {
      cardListType = 1 /* DueItem */;
      index = cardIndex - this.deck.newRepItems.length;
    }
    this.setCardListType(cardListType, index);
  }
  setCardListType(cardListType, cardIdx = null) {
    this.cardListType = cardListType;
    this.cardIdx = cardIdx;
  }
  nextCard() {
    if (this.iteratorOrder.repItemOrder === 4 /* EveryCardRandomDeckAndCard */) {
      this.nextRandomCard();
    } else {
      if (this.cardListType === null) {
        this.setCardListType(this.preferredCardListType);
      }
      if (!this.nextCardWithinCurrentList()) {
        if (this.cardListType === this.preferredCardListType) {
          this.setCardListType(Deck.otherListType(this.cardListType));
          if (!this.nextCardWithinCurrentList()) {
            this.setCardListType(null);
          }
        } else {
          this.cardIdx = null;
        }
      }
    }
    return this.cardIdx !== null && this.cardIdx !== void 0;
  }
  nextRandomCard() {
    const newCount = this.deck.newRepItems.length;
    const dueCount = this.deck.dueRepItems.length;
    if (newCount + dueCount > 0) {
      const weights = {};
      if (newCount > 0) weights[0 /* NewItem */] = newCount;
      if (dueCount > 0) weights[1 /* DueItem */] = dueCount;
      const [cardListType, index] = this.weightedRandomNumber.getRandomValues(weights);
      this.setCardListType(cardListType, index);
    } else {
      this.setCardListType(null);
    }
  }
  nextCardWithinCurrentList() {
    const cardList = this.deck.getRepItemListForRepItemState(this.cardListType);
    const result = cardList.length > 0;
    if (result) {
      switch (this.iteratorOrder.repItemOrder) {
        case 2 /* DueFirstSequential */:
        case 0 /* NewFirstSequential */:
          this.cardIdx = 0;
          break;
        case 3 /* DueFirstRandom */:
        case 1 /* NewFirstRandom */:
          this.cardIdx = globalRandomNumberProvider.getInteger(0, cardList.length - 1);
          break;
      }
    }
    return result;
  }
  moveCurrentCardToEndOfList() {
    this.ensureCurrentCard();
    const card = this.currentCard;
    this.deck.deleteRepItemAtIndex(this.cardIdx, this.cardListType);
    this.deck.appendRepItemToRootDeck(card);
    this.setNoCurrentCard();
  }
  setNoCurrentCard() {
    this.cardIdx = null;
  }
  ensureCurrentCard() {
    if (this.cardIdx === null || this.cardListType === null) throw new Error("no current card");
  }
  static getCardListTypeForIterator(iteratorOrder) {
    let result = null;
    switch (iteratorOrder.repItemOrder) {
      case 3 /* DueFirstRandom */:
      case 2 /* DueFirstSequential */:
        result = 1 /* DueItem */;
        break;
      case 1 /* NewFirstRandom */:
      case 0 /* NewFirstSequential */:
        result = 0 /* NewItem */;
        break;
    }
    return result;
  }
};
var DeckTreeIterator = class _DeckTreeIterator {
  constructor(iteratorOrder, baseDeckTree) {
    this.baseDeckTree = null;
    this.singleDeckIterator = new SingleDeckIterator(iteratorOrder);
    this.iteratorOrder = iteratorOrder;
    this.weightedRandomNumber = WeightedRandomNumber.create();
    this.setBaseDeck(baseDeckTree);
  }
  get hasCurrentCard() {
    return this.deckIdx !== null && this.deckIdx !== void 0 && this.singleDeckIterator.hasCurrentCard;
  }
  get currentTopicPath() {
    var _a2;
    return (_a2 = this.currentDeck) == null ? void 0 : _a2.getTopicPath();
  }
  get currentDeck() {
    if (this.deckIdx === null || this.deckIdx === void 0) return null;
    return this.deckArray[this.deckIdx];
  }
  get currentRepItem() {
    let result = null;
    if (this.deckIdx !== null && this.deckIdx !== void 0 && this.singleDeckIterator.hasCurrentCard)
      result = this.singleDeckIterator.currentCard;
    return result;
  }
  get currentQuestion() {
    var _a2;
    return ((_a2 = this.currentRepItem) == null ? void 0 : _a2.question) || null;
  }
  setBaseDeck(baseDeck) {
    this.baseDeckTree = baseDeck;
    this.singleDeckIterator.setNoCurrentCard();
  }
  setIteratorTopicPath(topicPath) {
    const iteratorDeck = this.baseDeckTree.getDeck(topicPath);
    this.deckArray = _DeckTreeIterator.filterForDecksWithCards(iteratorDeck.toDeckArray());
    this.setDeckIdx(null);
  }
  static filterForDecksWithCards(sourceArray) {
    const result = [];
    for (let idx = 0; idx < sourceArray.length; idx++) {
      const deck = sourceArray[idx];
      const hasAnyCards = deck.getRepItemCount(2 /* AnyItem */, false) > 0;
      if (hasAnyCards) {
        result.push(deck);
      }
    }
    return result;
  }
  setDeckIdx(deckIdx) {
    this.deckIdx = deckIdx;
    if (deckIdx !== null && deckIdx !== void 0)
      this.singleDeckIterator.setDeck(this.deckArray[deckIdx]);
  }
  nextRepItem() {
    let result = false;
    if (this.hasCurrentCard) {
      this.baseDeckTree.deleteCardFromAllDecks(this.currentRepItem, true);
    }
    if (this.iteratorOrder.repItemOrder === 4 /* EveryCardRandomDeckAndCard */) {
      result = this.nextCardEveryCardRandomDeck();
    } else {
      if (this.deckIdx === null || this.deckIdx === void 0) {
        this.chooseNextDeck(true);
      }
      while (this.deckIdx < this.deckArray.length) {
        if (this.singleDeckIterator.nextCard()) {
          result = true;
          break;
        }
        this.chooseNextDeck(false);
      }
    }
    if (!result) this.deckIdx = null;
    return result;
  }
  chooseNextDeck(firstTime) {
    switch (this.iteratorOrder.deckOrder) {
      case 0 /* PrevDeckComplete_Sequential */:
        this.deckIdx = firstTime ? 0 : this.deckIdx + 1;
        break;
      case 1 /* PrevDeckComplete_Random */: {
        const weights = {};
        let hasDeck = false;
        for (let i2 = 0; i2 < this.deckArray.length; i2++) {
          if (this.deckArray[i2].getRepItemCount(2 /* AnyItem */, false)) {
            weights[i2] = 1;
            hasDeck = true;
          }
        }
        if (hasDeck) {
          const [deckIdx, _2] = this.weightedRandomNumber.getRandomValues(weights);
          this.deckIdx = deckIdx;
        } else {
          this.deckIdx = this.deckArray.length;
        }
        break;
      }
    }
    if (this.deckIdx < this.deckArray.length) {
      this.singleDeckIterator.setDeck(this.deckArray[this.deckIdx]);
    }
  }
  nextCardEveryCardRandomDeck() {
    const weights = {};
    for (let i2 = 0; i2 < this.deckArray.length; i2++) {
      const cardCount = this.deckArray[i2].getRepItemCount(
        2 /* AnyItem */,
        false
      );
      if (cardCount) {
        weights[i2] = cardCount;
      }
    }
    if (Object.keys(weights).length === 0) return false;
    const [deckIdx, cardIdx] = this.weightedRandomNumber.getRandomValues(weights);
    this.setDeckIdx(deckIdx);
    this.singleDeckIterator.setNewOrDueCardIdx(cardIdx);
    return true;
  }
  deleteCurrentQuestionFromAllDecks() {
    this.singleDeckIterator.ensureCurrentCard();
    this.baseDeckTree.deleteQuestionFromAllDecks(this.currentQuestion, false);
    this.singleDeckIterator.setNoCurrentCard();
    return this.nextRepItem();
  }
  deleteCurrentRepItemFromAllDecks() {
    this.singleDeckIterator.ensureCurrentCard();
    this.baseDeckTree.deleteCardFromAllDecks(this.currentRepItem, true);
    this.singleDeckIterator.setNoCurrentCard();
    return this.nextRepItem();
  }
  moveCurrentRepItemToEndOfList() {
    this.singleDeckIterator.moveCurrentCardToEndOfList();
  }
  removeCurrentDeckIfEmpty() {
    if (this.currentDeck.getRepItemCount(2 /* AnyItem */, false) === 0) {
      this.deckArray.splice(this.deckIdx, 1);
      if (this.deckIdx < this.deckArray.length) this.setDeckIdx(this.deckIdx);
    }
  }
};

// src/ui/review-queue-loader.ts
var ReviewQueueLoader = class {
  constructor(plugin, osrCore, singleNote, reviewMode) {
    this.singleNote = null;
    this.osrCore = osrCore;
    this.singleNote = singleNote;
    this.reviewMode = reviewMode;
    this.plugin = plugin;
  }
  getSingleNote() {
    return this.singleNote;
  }
  getReviewMode() {
    return this.reviewMode;
  }
  setReviewMode(reviewMode) {
    this.reviewMode = reviewMode;
  }
  async loadReviewQueue() {
    if (this.plugin === null || this.plugin.dataManager.osrCore === null)
      throw new Error("SR plugin or OSR app core not initialized!!!");
    if (!this.plugin.dataManager.syncLock) {
      await this.plugin.dataManager.sync();
    }
    let deckTree;
    let remainingDeckTree;
    if (this.singleNote) {
      const singleNoteDeckData = await this.getPreparedDecksForSingleNoteReview(
        this.singleNote,
        this.reviewMode
      );
      deckTree = singleNoteDeckData.deckTree;
      remainingDeckTree = singleNoteDeckData.remainingDeckTree;
    } else {
      deckTree = this.osrCore.reviewableDeckTree;
      remainingDeckTree = this.reviewMode === 0 /* Cram */ ? this.osrCore.reviewableDeckTree : this.osrCore.remainingDeckTree;
    }
    const reviewSequencerData = this.getPreparedReviewSequencer(
      deckTree,
      remainingDeckTree,
      this.reviewMode
    );
    return reviewSequencerData.reviewSequencer;
  }
  getPreparedReviewSequencer(fullDeckTree, remainingDeckTree, reviewMode) {
    const deckIterator = this.createDeckTreeIterator(
      this.plugin.dataManager.data.settings
    );
    const reviewSequencer = new FlashcardReviewSequencer(
      reviewMode,
      deckIterator,
      this.plugin.dataManager.data.settings,
      SRAlgorithm.getInstance(),
      this.plugin.dataManager.osrCore.questionPostponementList,
      this.plugin.dataManager.osrCore.dueDateFlashcardHistogram
    );
    reviewSequencer.setDeckTree(fullDeckTree, remainingDeckTree);
    return { reviewSequencer, mode: reviewMode };
  }
  async getPreparedDecksForSingleNoteReview(file, mode) {
    const note = await this.plugin.dataManager.loadNote(file);
    const deckTree = new Deck("root", null);
    if (note) {
      note.appendCardsToDeck(deckTree);
    }
    const remainingDeckTree = DeckTreeFilter.filterForRemainingRepItems(
      this.plugin.dataManager.osrCore.questionPostponementList,
      deckTree,
      mode
    );
    return { deckTree, remainingDeckTree, mode };
  }
  createDeckTreeIterator(settings) {
    let cardOrder = RepItemOrder[settings.flashcardCardOrder];
    if (cardOrder === void 0) cardOrder = 2 /* DueFirstSequential */;
    let deckOrder = DeckOrder[settings.flashcardDeckOrder];
    if (deckOrder === void 0) deckOrder = 0 /* PrevDeckComplete_Sequential */;
    const iteratorOrder = {
      deckOrder,
      repItemOrder: cardOrder
    };
    return new DeckTreeIterator(iteratorOrder, null);
  }
};

// src/ui/obsidian-ui-components/item-views/review-queue-list-view.tsx
var import_obsidian29 = require("obsidian");
var REVIEW_QUEUE_VIEW_TYPE = "review-queue-list-view";
var ReviewQueueListView = class extends import_obsidian29.ItemView {
  constructor(leaf, nextNoteReviewHandler, settings, plugin) {
    super(leaf);
    this.headerEl = null;
    this.treeEl = null;
    this.nextNoteReviewHandler = nextNoteReviewHandler;
    this.settings = settings;
    this.plugin = plugin;
    if (this.settings.enableNoteReviewPaneOnStartup) {
      this.registerEvent(this.app.workspace.on("file-open", () => this.redraw()));
      this.registerEvent(this.app.vault.on("rename", () => this.redraw()));
    }
  }
  get noteReviewQueue() {
    return this.nextNoteReviewHandler.noteReviewQueue;
  }
  getViewType() {
    return REVIEW_QUEUE_VIEW_TYPE;
  }
  getDisplayText() {
    return t("NOTES_REVIEW_QUEUE");
  }
  getIcon() {
    return "SpacedRepIcon";
  }
  onOpen() {
    this.redraw();
    return Promise.resolve();
  }
  onHeaderMenu(menu) {
    menu.addItem((item) => {
      item.setTitle(t("CLOSE")).setIcon("cross").onClick(() => {
        this.app.workspace.detachLeavesOfType(REVIEW_QUEUE_VIEW_TYPE);
      });
    });
  }
  redraw() {
    this.contentEl.empty();
    this.contentEl.addClass("sr-note-review-page");
    this.headerEl = this.contentEl.createDiv("sr-note-review-header");
    const titleWrapper = this.headerEl.createDiv("sr-note-review-header-title-wrapper");
    const titleIcon = titleWrapper.createDiv("sr-note-review-header-title-icon");
    (0, import_obsidian29.setIcon)(titleIcon, "lucide-file-clock");
    titleWrapper.createDiv("sr-note-review-header-title").setText(t("OPEN_NOTE_FOR_REVIEW"));
    const subTitleWrapper = this.contentEl.createDiv("sr-note-review-header-subtitle-wrapper");
    subTitleWrapper.createDiv("sr-note-review-header-subtitle").setText(
      !this.noteReviewQueue.reviewDecks || this.noteReviewQueue.reviewDecks.size === 0 ? t("NOTE_REVIEW_QUEUE_EMPTY_HINT") : t("NOTE_REVIEW_QUEUE_HINT")
    );
    this.treeEl = this.contentEl.createDiv("tree-item nav-folder mod-root");
    if (!this.noteReviewQueue.reviewDecks) return;
    this.createTree(this.treeEl);
  }
  createTree(parentEl) {
    const childrenEl = parentEl.createDiv(
      "tree-item-children nav-folder-children"
    );
    for (const [deckKey, deck] of this.noteReviewQueue.reviewDecks) {
      const deckCollapsed = !deck.activeFolders.has(deck.deckName);
      this.createDeckTreeItem(childrenEl, deckKey, deck, deckCollapsed);
    }
  }
  createDeckTreeItem(parentEl, deckKey, deck, deckCollapsed) {
    const deckFolderEl = this.createFolder(
      parentEl,
      deckKey,
      deckCollapsed,
      false,
      deck
    ).getElementsByClassName("tree-item-children nav-folder-children")[0];
    if (deck.newNotes.length > 0) {
      this.createNewNotesFolder(deckFolderEl, deck, deckCollapsed);
    }
    if (deck.scheduledNotes.length > 0) {
      this.createScheduledNotesFolder(deckFolderEl, deck, deckCollapsed);
    }
  }
  createNewNotesFolder(parentEl, deck, deckCollapsed) {
    const activeFile = this.app.workspace.getActiveFile();
    const newNotesFolderEl = this.createFolder(
      parentEl,
      t("NEW"),
      !deck.activeFolders.has(t("NEW")),
      deckCollapsed,
      deck
    );
    for (const newFile of deck.newNotes) {
      const fileIsOpen = activeFile !== void 0 && activeFile !== null && newFile.path === activeFile.path;
      if (fileIsOpen) {
        deck.activeFolders.add(deck.deckName);
        deck.activeFolders.add(t("NEW"));
        this.changeFolderFolding(newNotesFolderEl);
        this.changeFolderFolding(parentEl);
      }
      this.createFile(
        newNotesFolderEl,
        newFile.tfile,
        fileIsOpen,
        !deck.activeFolders.has(t("NEW")),
        deck
      );
    }
  }
  createScheduledNotesFolder(parentEl, deck, deckCollapsed) {
    const activeFile = this.app.workspace.getActiveFile();
    const now2 = Date.now();
    let currUnix = -1;
    let scheduleFolderEl = null, folderTitle = "";
    const maxDaysToRender = this.settings.maxNDaysNotesReviewQueue;
    for (const sNote of deck.scheduledNotes) {
      if (sNote.dueUnix !== currUnix) {
        const nDays = Math.ceil((sNote.dueUnix - now2) / TICKS_PER_DAY);
        if (nDays > maxDaysToRender) {
          break;
        }
        if (nDays === -1) {
          folderTitle = t("YESTERDAY");
        } else if (nDays === 0) {
          folderTitle = t("TODAY");
        } else if (nDays === 1) {
          folderTitle = t("TOMORROW");
        } else {
          folderTitle = formatDateWithMoment(
            sNote.dueUnix,
            this.settings.preferredDateFormatForNoteReviewQueue
          );
        }
        scheduleFolderEl = this.createFolder(
          parentEl,
          folderTitle,
          !deck.activeFolders.has(folderTitle),
          deckCollapsed,
          deck
        );
        currUnix = sNote.dueUnix;
      }
      const fileIsOpen = activeFile !== null && sNote.note.path === activeFile.path;
      if (fileIsOpen) {
        deck.activeFolders.add(deck.deckName);
        deck.activeFolders.add(folderTitle);
        if (scheduleFolderEl) this.changeFolderFolding(scheduleFolderEl);
        this.changeFolderFolding(parentEl);
      }
      if (scheduleFolderEl) {
        this.createFile(
          scheduleFolderEl,
          sNote.note.tfile,
          fileIsOpen,
          !deck.activeFolders.has(folderTitle),
          deck
        );
      }
    }
  }
  createFolder(parentEl, folderTitle, collapsed, hidden, deck) {
    const folderEl = parentEl.createDiv("tree-item nav-folder");
    const folderTitleEl = folderEl.createDiv("tree-item-self nav-folder-title");
    folderTitleEl.classList.add("is-clickable");
    const childrenEl = folderEl.createDiv(
      "tree-item-children nav-folder-children"
    );
    const collapseIconEl = folderTitleEl.createDiv(
      "tree-item-icon collapse-icon nav-folder-collapse-indicator"
    );
    (0, import_obsidian29.setIcon)(collapseIconEl, "chevron-down");
    folderTitleEl.createDiv("tree-item-inner nav-folder-title-content").setText(folderTitle);
    if (collapsed && !folderEl.hasClass("is-collapsed")) {
      folderEl.addClass("is-collapsed");
      collapseIconEl.addClass("is-collapsed");
    } else {
      folderEl.removeClass("is-collapsed");
      const collapseIconEl2 = folderEl.find("div.nav-folder-collapse-indicator");
      collapseIconEl2.removeClass("is-collapsed");
    }
    if (hidden) {
      folderEl.setCssProps({ display: "none" });
    }
    folderTitleEl.onClickEvent(() => {
      this.changeFolderFolding(folderEl, !folderEl.hasClass("is-collapsed"));
      childrenEl.setCssProps({
        display: !folderEl.hasClass("is-collapsed") ? "block" : "none"
      });
      if (!folderEl.hasClass("is-collapsed")) {
        deck.activeFolders.delete(folderTitle);
      } else {
        deck.activeFolders.add(folderTitle);
      }
    });
    return folderEl;
  }
  createFile(folderEl, file, fileElActive, hidden, deck) {
    const childrenEl = folderEl.getElementsByClassName(
      "tree-item-children nav-folder-children"
    )[0];
    const navFileEl = childrenEl.createDiv("nav-file");
    if (hidden) {
      childrenEl.setCssProps({
        display: "none"
      });
    }
    const navFileTitle = navFileEl.createDiv("tree-item-self nav-file-title");
    navFileTitle.addClass("is-clickable");
    if (fileElActive) {
      navFileTitle.addClass("is-active");
    }
    const navFileTitleInner = navFileTitle.createDiv(
      "tree-item-inner nav-file-title-content"
    );
    navFileTitleInner.setText(file.basename);
    navFileTitleInner.addEventListener(
      "click",
      (event) => {
        event.preventDefault();
        void this.nextNoteReviewHandler.openNote(deck.deckName, file);
        return false;
      },
      false
    );
    const navFileContextBtn = navFileTitle.createDiv(
      "sr-review-context-btn clickable-icon"
    );
    (0, import_obsidian29.setIcon)(navFileContextBtn, "ellipsis-vertical");
    navFileContextBtn.addEventListener("click", (event) => {
      event.preventDefault();
      const fileMenu = new import_obsidian29.Menu();
      fileMenu.addItem((item) => {
        item.setTitle(
          t("REVIEW_DIFFICULTY_FILE_MENU", {
            difficulty: this.plugin.dataManager.data.settings.flashcardEasyText
          })
        ).setIcon("SpacedRepIcon").onClick(() => {
          void this.plugin.dataManager.saveNoteReviewResponse(
            file,
            0 /* Easy */
          );
        });
      });
      fileMenu.addItem((item) => {
        item.setTitle(
          t("REVIEW_DIFFICULTY_FILE_MENU", {
            difficulty: this.plugin.dataManager.data.settings.flashcardGoodText
          })
        ).setIcon("SpacedRepIcon").onClick(() => {
          void this.plugin.dataManager.saveNoteReviewResponse(
            file,
            1 /* Good */
          );
        });
      });
      fileMenu.addItem((item) => {
        item.setTitle(
          t("REVIEW_DIFFICULTY_FILE_MENU", {
            difficulty: this.plugin.dataManager.data.settings.flashcardHardText
          })
        ).setIcon("SpacedRepIcon").onClick(() => {
          void this.plugin.dataManager.saveNoteReviewResponse(
            file,
            2 /* Hard */
          );
        });
      });
      fileMenu.addSeparator();
      if (this.plugin.dataManager.data.settings.showDeleteButtonInFileMenu) {
        fileMenu.addItem((item) => {
          item.setTitle(t("DELETE_NOTE_SCHEDULING_DATA_IN_NOTE")).setIcon("trash").setWarning(true).onClick(() => {
            new ConfirmationModal(
              this.plugin.app,
              t("DELETE_NOTE_SCHEDULING_DATA_IN_NOTE"),
              t("CONFIRM_NOTE_SCHEDULING_DATA_IN_NOTE_DELETION"),
              t("NOTE_SCHEDULING_DATA_IN_NOTE_DELETION_IN_PROGRESS"),
              async () => {
                await DataStore.instance.fileModifier.deleteNoteSchedulingDataInNote(
                  file,
                  this.plugin.dataManager.data.settings.deleteTagsOnSchedulingDataDeletion,
                  this.plugin.dataManager.data.settings.tagsToReview
                );
              }
            ).open();
          });
        });
      }
      fileMenu.showAtPosition({
        x: event.pageX,
        y: event.pageY
      });
      fileMenu.showAtMouseEvent(event);
      return false;
    });
  }
  changeFolderFolding(folderEl, collapsed = false) {
    var _a2;
    const childEl = ((_a2 = folderEl.firstElementChild) == null ? void 0 : _a2.firstElementChild) || null;
    if (collapsed && !folderEl.hasClass("is-collapsed")) {
      folderEl.addClass("is-collapsed");
      if (childEl) childEl.classList.add("is-collapsed");
    } else {
      folderEl.removeClass("is-collapsed");
      if (childEl) childEl.classList.remove("is-collapsed");
    }
  }
};

// src/ui/sidebar-manager.tsx
var SidebarManager = class {
  constructor(plugin, settingsManager) {
    this.reviewQueueListView = null;
    this.plugin = plugin;
    this.settingsManager = settingsManager;
  }
  get app() {
    return this.plugin.app;
  }
  redraw() {
    if (this.reviewQueueListView === null) return;
    this.reviewQueueListView.redraw();
  }
  getActiveLeaf(type) {
    const leaves = this.app.workspace.getLeavesOfType(type);
    if (leaves.length === 0) {
      return this.app.workspace.getRightLeaf(false);
    }
    return leaves[0];
  }
  init() {
    this.plugin.registerView(REVIEW_QUEUE_VIEW_TYPE, (leaf) => {
      return this.reviewQueueListView = new ReviewQueueListView(
        leaf,
        this.plugin.nextNoteReviewHandler,
        this.settingsManager.settings,
        this.plugin
      );
    });
  }
  async activateReviewQueueViewPanel() {
    if (this.settingsManager.settings.enableNoteReviewPaneOnStartup) {
      const activeLeaf = this.getActiveLeaf(REVIEW_QUEUE_VIEW_TYPE);
      if (!activeLeaf) return;
      await activeLeaf.setViewState({
        type: REVIEW_QUEUE_VIEW_TYPE,
        active: true
      });
    }
  }
  async openReviewQueueView() {
    const reviewQueueLeaf = this.getActiveLeaf(REVIEW_QUEUE_VIEW_TYPE);
    if (!reviewQueueLeaf) return;
    await this.app.workspace.revealLeaf(reviewQueueLeaf);
  }
};

// src/ui/status-bar-manager.tsx
var import_obsidian31 = require("obsidian");

// src/ui/obsidian-ui-components/statusbar-items/icon-statusbar-item.tsx
var import_obsidian30 = require("obsidian");

// src/ui/obsidian-ui-components/statusbar-items/statusbar-item.tsx
var StatusBarItem = class {
  constructor(plugin, type, props) {
    var _a2;
    this.type = type;
    this.statusBarItem = plugin.addStatusBarItem();
    this.statusBarItem.addClass("status-bar-item");
    this.statusBarItem.addClass(type);
    this.statusBarItem.addClass("sr-status-bar-item");
    this.segments = [];
    if (props.show === void 0 || props.show === false) {
      this.statusBarItem.addClass("sr-is-hidden");
    }
    if (props.onClick !== void 0) {
      this.statusBarItem.addClass("mod-clickable");
      this.statusBarItem.addEventListener("click", () => {
        if (props.onClick === void 0) return;
        void props.onClick();
      });
    }
    if (props.tooltip !== void 0) {
      this.statusBarItem.setAttribute("aria-label", props.tooltip);
      this.statusBarItem.setAttribute("aria-label-position", (_a2 = props.tooltipPosition) != null ? _a2 : "top");
    }
    if (props.segments !== void 0) {
      for (const segment of props.segments) {
        this.addSegment(segment);
      }
    }
  }
  getItem() {
    return this.statusBarItem;
  }
  show() {
    if (this.statusBarItem.hasClass("sr-is-hidden")) {
      this.statusBarItem.removeClass("sr-is-hidden");
    }
  }
  hide() {
    if (!this.statusBarItem.hasClass("sr-is-hidden")) {
      this.statusBarItem.addClass("sr-is-hidden");
    }
  }
  getStatusBarItemType() {
    return this.type;
  }
  addSegment(content) {
    content.addClass("sr-status-bar-item-segment");
    this.segments.push(content);
    this.statusBarItem.appendChild(content);
    return content;
  }
};

// src/ui/obsidian-ui-components/statusbar-items/icon-statusbar-item.tsx
var IconStatusBarItem = class extends StatusBarItem {
  constructor(plugin, type, props) {
    super(plugin, type, props);
    this.icon = "";
    this.iconEl = null;
    this.hideIcon = false;
    this.icon = props.icon;
    this.hideIcon = props.hideIcon !== void 0 ? props.hideIcon : false;
    this.setStatusBarItemIcon(props.icon);
  }
  setStatusBarItemIcon(icon) {
    this.icon = icon;
    if (this.iconEl === null || !this.statusBarItem.hasChildNodes()) {
      this.iconEl = activeDocument.createElement("span");
      this.iconEl.addClass("status-bar-item-icon");
      this.addSegment(this.iconEl);
    } else {
      if (this.iconEl !== null) {
        this.iconEl.empty();
      }
    }
    (0, import_obsidian30.setIcon)(this.iconEl, this.icon);
    if (!this.iconEl.hasClass("status-bar-item-icon")) {
      this.iconEl.addClass("status-bar-item-icon");
    }
    this.setHideIcon(this.hideIcon);
  }
  setHideIcon(hideIcon) {
    this.hideIcon = hideIcon;
    if (this.iconEl === null) return;
    if (hideIcon) {
      if (this.iconEl.hasClass("sr-is-hidden")) return;
      this.iconEl.addClass("sr-is-hidden");
    } else {
      if (!this.iconEl.hasClass("sr-is-hidden")) return;
      this.iconEl.removeClass("sr-is-hidden");
    }
  }
};

// src/ui/obsidian-ui-components/statusbar-items/text-statusbar-item.tsx
var TextStatusBarItem = class extends IconStatusBarItem {
  constructor(plugin, type, props) {
    super(plugin, type, {
      icon: props.icon ? props.icon : "",
      hideIcon: props.hideIcon,
      show: props.show,
      tooltip: props.tooltip,
      tooltipPosition: props.tooltipPosition,
      onClick: props.onClick
    });
    this.text = "";
    this.setText(props.text, false);
  }
  setText(text, cleanSegments = true) {
    if (cleanSegments) {
      this.segments = [];
      this.statusBarItem.empty();
      this.iconEl = null;
      this.setStatusBarItemIcon(this.icon);
    }
    if (typeof text === "string") {
      this.text = text;
      this.createTextSegment(text);
    } else if (Array.isArray(text)) {
      this.text = text;
      for (const textSegment of text) {
        this.createTextSegment(textSegment);
      }
    }
  }
  getText() {
    return this.text;
  }
  createTextSegment(text) {
    const segment = activeDocument.createElement("span");
    segment.setText(text);
    this.addSegment(segment);
  }
};

// src/ui/obsidian-ui-components/statusbar-items/counter-statusbar-item.tsx
var CounterStatusBarItem = class extends TextStatusBarItem {
  constructor(plugin, type, props) {
    super(plugin, type, {
      ...props,
      text: `${props.count} ${props.text}`
    });
    this.count = 0;
    this.count = props.count;
  }
  setCounter(count) {
    const oldCount = this.count;
    this.count = count;
    if (typeof this.text === "string") {
      const textWithoutCount = this.text.replace(oldCount.toString(), "");
      this.setText(`${this.count}${textWithoutCount}`);
    }
  }
  getCount() {
    return this.count;
  }
};

// src/ui/status-bar-manager.tsx
var StatusBarItemTypesArray = [
  "card-review",
  "note-review",
  "update-available"
];
var StatusBarManager = class {
  constructor(plugin, settingsManager) {
    this.plugin = plugin;
    this.settingsManager = settingsManager;
    this.statusBarItems = [];
  }
  setCount(count, showItems, statusBarItemType) {
    const statusBarItem = this.statusBarItems.find(
      (statusBarItem2) => statusBarItem2.getStatusBarItemType() === statusBarItemType
    );
    if (statusBarItem === void 0) return;
    statusBarItem.setCounter(count);
    if (showItems && count > 0) {
      statusBarItem.show();
    } else {
      statusBarItem.hide();
    }
  }
  async showStatusBarItems(showItems, showCardStatusBarItem, showNoteStatusBarItem, showUpdateAvailableStatusBarItem) {
    if (this.statusBarItems.length === 0) {
      await this.createStatusBarItems();
    }
    const showCardItem = showCardStatusBarItem === void 0 ? showItems : showCardStatusBarItem;
    const showNoteItem = showNoteStatusBarItem === void 0 ? showItems : showNoteStatusBarItem;
    const showUpdateAvailableItem = showUpdateAvailableStatusBarItem === void 0 ? showItems : showUpdateAvailableStatusBarItem;
    for (const statusBarItem of this.statusBarItems) {
      if (showItems) {
        if (statusBarItem.getStatusBarItemType() === "update-available" && statusBarItem.getText() === "") {
          statusBarItem.hide();
          return;
        }
        switch (statusBarItem.getStatusBarItemType()) {
          case "card-review":
            if (showItems && showCardItem) {
              statusBarItem.show();
            } else {
              statusBarItem.hide();
            }
            break;
          case "note-review":
            if (showItems && showNoteItem) {
              statusBarItem.show();
            } else {
              statusBarItem.hide();
            }
            break;
          case "update-available":
            if (showItems && showUpdateAvailableItem) {
              await this.checkAndUpdatePluginVersion().then((_2) => {
                statusBarItem.show();
              });
            } else {
              statusBarItem.hide();
            }
            break;
          default:
            statusBarItem.show();
        }
      } else {
        statusBarItem.hide();
      }
    }
  }
  async createStatusBarItems() {
    if (this.statusBarItems.length > 0) return;
    for (const statusBarItemType of StatusBarItemTypesArray) {
      let statusBarItem = void 0;
      switch (statusBarItemType) {
        case "card-review":
          statusBarItem = new CounterStatusBarItem(this.plugin, statusBarItemType, {
            icon: "SpacedRepIcon",
            show: false,
            count: 0,
            hideIcon: false,
            text: " card(s) due",
            tooltip: t("OPEN_DECK_FOR_REVIEW"),
            tooltipPosition: "top",
            onClick: async () => {
              if (this.plugin.uiManager === null)
                throw new Error("UI manager not initialized!!!");
              await this.plugin.uiManager.openDeckContainer(
                1 /* Review */
              );
            }
          });
          break;
        case "note-review":
          statusBarItem = new CounterStatusBarItem(this.plugin, statusBarItemType, {
            icon: "lucide-file-clock",
            show: false,
            text: " note(s) due",
            count: 0,
            hideIcon: false,
            tooltip: t("OPEN_NOTE_FOR_REVIEW"),
            tooltipPosition: "top",
            onClick: async () => {
              if (this.plugin.dataManager === null || this.plugin.dataManager.osrCore === null)
                throw new Error("SR plugin or OSR app core not initialized!!!");
              if (this.plugin.nextNoteReviewHandler === null)
                throw new Error("Next note review handler not initialized!!!");
              if (!this.plugin.dataManager.syncLock) {
                await this.plugin.dataManager.sync();
                await this.plugin.nextNoteReviewHandler.reviewNextNoteModal();
              }
            }
          });
          break;
        case "update-available":
          statusBarItem = new TextStatusBarItem(this.plugin, statusBarItemType, {
            icon: "lucide-circle-arrow-up",
            show: false,
            hideIcon: false,
            text: "",
            tooltip: t("UPDATE_AVAILABLE"),
            tooltipPosition: "top"
          });
          break;
      }
      this.statusBarItems.push(statusBarItem);
    }
    if (this.settingsManager.settings.showStatusBar && this.settingsManager.settings.showUpdateAvailableStatusBarItem) {
      await this.checkAndUpdatePluginVersion();
    }
  }
  async checkAndUpdatePluginVersion() {
    const newestVersion = await this.getNewestVersion();
    if (this.plugin.manifest.version === newestVersion) return;
    const updateItem = this.statusBarItems.find(
      (statusBarItem) => statusBarItem.getStatusBarItemType() === "update-available"
    );
    if (updateItem !== void 0) {
      updateItem.setText("Spaced Repetition: new Update!");
    }
  }
  async getNewestVersion() {
    try {
      const response = await (0, import_obsidian31.request)({
        url: "https://api.github.com/repos/st3v3nmw/obsidian-spaced-repetition/releases/latest"
      });
      return (await JSON.parse(response)).tag_name;
    } catch (e2) {
      console.warn(e2);
      return this.plugin.manifest.version;
    }
  }
};

// src/ui/tab-view-manager.tsx
var TabViewManager = class {
  // Add any needed resource
  constructor(plugin, settingsManager) {
    this.reviewQueueLoader = null;
    // Add any new other tab view types to this, then they'll be automatically registered
    this.tabViewTypes = [
      {
        type: SR_TAB_VIEW,
        viewCreator: (leaf) => {
          return new SRTabView(
            leaf,
            this.plugin,
            this.settingsManager.settings,
            this.reviewQueueLoader
          );
        }
      }
    ];
    this.settingsManager = settingsManager;
    this.plugin = plugin;
  }
  /**
   * Opens the Spaced Repetition tab view in the application.
   *
   * This method sets up the necessary state for the tab view and invokes the
   * internal method to open the tab view with the specified parameters.
   *
   * @param osrAppCore - The core application instance used for managing reviewable decks.
   * @param reviewMode - The mode of flashcard review.
   * @param singleNote - Optional parameter specifying a single note to review.
   *                     If provided, the tab view will focus on this note.
   *
   * @returns {Promise<void>} - A promise that resolves when the tab view is opened.
   */
  async openSRTabView(reviewQueueLoader) {
    this.reviewQueueLoader = reviewQueueLoader;
    await this.openTabView(SR_TAB_VIEW, true);
  }
  /**
   * Closes all open tab views in the application.
   *
   * This method iterates over all registered tab view types and detaches
   * their corresponding leaves from the workspace, effectively closing them.
   */
  closeAllTabViews() {
    this.forEachTabViewType((viewType) => {
      this.plugin.app.workspace.getLeavesOfType(viewType.type).forEach((leaf) => leaf.detach());
    });
  }
  forEachTabViewType(callback2) {
    this.tabViewTypes.forEach((type) => callback2(type));
  }
  registerAllTabViews() {
    this.forEachTabViewType(
      (viewType) => this.plugin.registerView(viewType.type, viewType.viewCreator)
    );
  }
  async openTabView(type, newLeaf) {
    const { workspace } = this.plugin.app;
    let leaf;
    const leaves = workspace.getLeavesOfType(type);
    if (leaves.length > 0) {
      leaf = leaves[0];
    } else {
      leaf = workspace.getLeaf(newLeaf);
      if (leaf !== null && leaf !== void 0) {
        await leaf.setViewState({ type, active: true });
      }
    }
    if (leaf !== null && leaf !== void 0) {
      await workspace.revealLeaf(leaf);
    }
  }
};

// src/ui/ui-manager.tsx
var UIManager2 = class {
  constructor(plugin, settingsManager) {
    this.uiState = 0 /* Closed */;
    this.isSRInFocus = false;
    this.contentManager = null;
    this.ribbonIcon = null;
    this.externalModalObserver = null;
    this.plugin = plugin;
    this.settingsManager = settingsManager;
    appIcon();
    this.tabViewManager = new TabViewManager(this.plugin, this.settingsManager);
    this.tabViewManager.registerAllTabViews();
    this.sidebarManager = new SidebarManager(this.plugin, this.settingsManager);
    this.statusBarManager = new StatusBarManager(this.plugin, this.settingsManager);
    this.plugin.registerEvent(
      this.plugin.app.workspace.on("file-menu", (menu, file) => {
        this.fileMenuHandler(menu, file);
      })
    );
    const settingsTab = new SRSettingTab(this.plugin.app, this.plugin, this, settingsManager);
    this.plugin.addSettingTab(settingsTab);
  }
  async onLayoutReady() {
    this.tabViewManager.closeAllTabViews();
    await this.sidebarManager.activateReviewQueueViewPanel();
    await this.plugin.dataManager.sync();
    await this.statusBarManager.createStatusBarItems();
    this.sidebarManager.init();
    this.showRibbonIcon(this.settingsManager.settings.showRibbonIcon);
    this.registerSRFocusListener();
  }
  destroy() {
    this.removeSRFocusListener();
  }
  async updateStatusBar() {
    if (this.plugin.dataManager.osrCore === null)
      throw new Error("SR plugin or OSR app core not initialized!!!");
    const settings = this.settingsManager.settings;
    await this.statusBarManager.showStatusBarItems(
      settings.showStatusBar,
      settings.showCardStatusBarItem,
      settings.showNoteStatusBarItem,
      settings.showUpdateAvailableStatusBarItem
    );
    if (settings.showStatusBar) {
      if (this.plugin.dataManager.osrCore.remainingDeckTree !== null) {
        this.statusBarManager.setCount(
          this.plugin.dataManager.osrCore.remainingDeckTree.getRepItemCount(
            2 /* AnyItem */,
            true
          ),
          settings.showStatusBar && settings.showCardStatusBarItem,
          "card-review"
        );
      }
      this.statusBarManager.setCount(
        this.plugin.dataManager.osrCore.noteReviewQueue.dueNotesCount,
        settings.showStatusBar && settings.showNoteStatusBarItem,
        "note-review"
      );
    }
  }
  registerSRFocusListener() {
    this.plugin.registerEvent(
      this.plugin.app.workspace.on("active-leaf-change", (leaf) => {
        this.handleFocusChange(leaf);
      })
    );
    this.externalModalObserver = new MutationObserver((mutationList) => {
      this.handleExternalModalOpen(mutationList);
    });
    this.externalModalObserver.observe(activeDocument.body, {
      childList: true,
      subtree: true
    });
  }
  removeSRFocusListener() {
    this.setSRViewInFocus(false);
  }
  handleFocusChange(leaf) {
    this.setSRViewInFocus(
      leaf !== null && leaf !== void 0 && leaf.view instanceof SRTabView
    );
  }
  handleExternalModalOpen(mutationList) {
    if (this.settingsManager.settings.openViewInNewTab && // Is a modal opening relevant for focus?
    mutationList.length > 0 && mutationList.filter(
      (mutation) => mutation.type === "childList" && (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0)
    ).length > 0) {
      const modal = activeDocument.querySelector(".modal-container");
      this.setSRViewInFocus(
        (modal === null || modal === void 0) && this.plugin.app.workspace.getActiveViewOfType(SRTabView) !== null && this.plugin.app.workspace.getActiveViewOfType(SRTabView) !== void 0
      );
    }
  }
  setUIState(state) {
    this.uiState = state;
  }
  setContentManager(contentManager) {
    this.contentManager = contentManager;
  }
  /**
   * Brings the current Obsidian window to the foreground on desktop.
   *
   * Reminders can optionally auto-open review, so we try to focus the existing app window
   * instead of spawning a detached-looking modal behind another application.
   */
  focusObsidianWindow() {
    var _a2, _b, _c, _d, _e, _f, _g, _h;
    if (!import_obsidian32.Platform.isDesktopApp) {
      return;
    }
    const activeLeaf = this.plugin.app.workspace.activeLeaf;
    if (activeLeaf !== null) {
      this.plugin.app.workspace.setActiveLeaf(activeLeaf, { focus: true });
      (_b = (_a2 = activeLeaf.getContainer()) == null ? void 0 : _a2.win) == null ? void 0 : _b.focus();
    }
    (_c = activeDocument.defaultView) == null ? void 0 : _c.focus();
    const electronWindow = this.getElectronWindow();
    if (electronWindow !== null) {
      if ((_d = electronWindow.isMinimized) == null ? void 0 : _d.call(electronWindow)) {
        (_e = electronWindow.restore) == null ? void 0 : _e.call(electronWindow);
      }
      (_f = electronWindow.show) == null ? void 0 : _f.call(electronWindow);
      (_g = electronWindow.focus) == null ? void 0 : _g.call(electronWindow);
      (_h = electronWindow.moveTop) == null ? void 0 : _h.call(electronWindow);
    }
  }
  /**
   * Resolves the current Electron window using either the modern or legacy remote bridge.
   *
   * Different Obsidian/Electron combinations expose window APIs through `@electron/remote`
   * or `electron.remote`, so the reminder feature probes both paths and degrades quietly.
   */
  getElectronWindow() {
    var _a2, _b, _c, _d;
    const requireFn = (_a2 = activeDocument.defaultView) == null ? void 0 : _a2.require;
    if (requireFn === void 0) {
      return null;
    }
    try {
      const remoteModule = requireFn("@electron/remote");
      const currentWindow = (_b = remoteModule == null ? void 0 : remoteModule.getCurrentWindow) == null ? void 0 : _b.call(remoteModule);
      if (currentWindow !== null && currentWindow !== void 0) {
        return currentWindow;
      }
    } catch (e2) {
    }
    try {
      const electronModule = requireFn("electron");
      const currentWindow = (_d = (_c = electronModule == null ? void 0 : electronModule.remote) == null ? void 0 : _c.getCurrentWindow) == null ? void 0 : _d.call(_c);
      if (currentWindow !== null && currentWindow !== void 0) {
        return currentWindow;
      }
    } catch (e2) {
    }
    return null;
  }
  /**
   * Dispatches the configured reminder attention signals.
   *
   * Notice, sound, dock bounce, and optional auto-open are deliberately separated so users can
   * enable only the channels that make sense for their workflow.
   */
  async notifyReviewReminder() {
    const settings = this.settingsManager.settings;
    const reminderMessage = settings.reviewReminderMessage.trim() || t("REVIEW_REMINDER_NOTICE");
    if (settings.reviewReminderShowNotice) {
      new import_obsidian32.Notice(reminderMessage, 5e3);
    }
    if (settings.reviewReminderPlaySound) {
      await this.playReviewReminderBeep();
    }
    if (settings.reviewReminderBounceDock) {
      this.bounceDockIcon();
    }
  }
  /**
   * Plays a short synthesized alert tone for desktop reminders.
   *
   * Web Audio availability differs across Electron environments, so this stays best-effort and
   * exits silently when audio cannot be initialized or resumed.
   */
  async playReviewReminderBeep() {
    var _a2, _b;
    if (!import_obsidian32.Platform.isDesktopApp) {
      return;
    }
    const windowObject = activeDocument.defaultView;
    const AudioContextCtor = (_b = (_a2 = windowObject == null ? void 0 : windowObject.AudioContext) != null ? _a2 : windowObject == null ? void 0 : windowObject.webkitAudioContext) != null ? _b : null;
    if (AudioContextCtor === null) {
      return;
    }
    let context = null;
    try {
      context = new AudioContextCtor();
      if (context.state === "suspended") {
        await context.resume();
      }
      if (context.state !== "running") {
        return;
      }
      const oscillator = context.createOscillator();
      const gainNode = context.createGain();
      oscillator.type = "sine";
      oscillator.frequency.value = 880;
      gainNode.gain.setValueAtTime(1e-4, context.currentTime);
      gainNode.gain.exponentialRampToValueAtTime(0.08, context.currentTime + 0.02);
      gainNode.gain.exponentialRampToValueAtTime(1e-4, context.currentTime + 0.35);
      oscillator.connect(gainNode);
      gainNode.connect(context.destination);
      oscillator.start();
      oscillator.stop(context.currentTime + 0.35);
      await new Promise((resolve2) => {
        oscillator.onended = () => resolve2();
      });
    } catch (e2) {
    } finally {
      if (context !== null && context.state !== "closed") {
        void context.close().catch(() => {
        });
      }
    }
  }
  /**
   * Requests a dock bounce on desktop when reminders fire.
   *
   * As with window focusing, we support both remote APIs because plugin hosts may expose either
   * `@electron/remote` or the legacy `electron.remote` bridge.
   */
  bounceDockIcon() {
    var _a2, _b, _c, _d, _e, _f;
    if (!import_obsidian32.Platform.isDesktopApp) {
      return;
    }
    const requireFn = (_a2 = activeDocument.defaultView) == null ? void 0 : _a2.require;
    if (requireFn === void 0) {
      return;
    }
    let electronApp = null;
    try {
      const remoteModule = requireFn("@electron/remote");
      electronApp = (_b = remoteModule == null ? void 0 : remoteModule.app) != null ? _b : null;
    } catch (e2) {
    }
    if (electronApp === null) {
      try {
        const electronModule = requireFn("electron");
        electronApp = (_d = (_c = electronModule == null ? void 0 : electronModule.remote) == null ? void 0 : _c.app) != null ? _d : null;
      } catch (e2) {
      }
    }
    (_f = (_e = electronApp == null ? void 0 : electronApp.dock) == null ? void 0 : _e.bounce) == null ? void 0 : _f.call(_e, "informational");
  }
  async openDeckContainer(mode, singleNote) {
    if (this.plugin.dataManager.osrCore === null)
      throw new Error("SR plugin or OSR app core not initialized!!!");
    if (this.plugin.dataManager.syncLock) {
      return;
    }
    this.focusObsidianWindow();
    await this.plugin.dataManager.sync();
    const settings = this.settingsManager.settings;
    const isMobile = import_obsidian32.Platform.isMobile || EmulatedPlatform().isMobile;
    const openInNewTab = !isMobile && settings.openViewInNewTab || isMobile && settings.openViewInNewTabMobile;
    const reviewQueueLoader = new ReviewQueueLoader(
      this.plugin,
      this.plugin.dataManager.osrCore,
      singleNote != null ? singleNote : null,
      mode
    );
    if (openInNewTab) {
      await this.tabViewManager.openSRTabView(reviewQueueLoader);
    } else {
      this.openFlashcardModal(reviewQueueLoader);
    }
    this.focusObsidianWindow();
  }
  openFlashcardModal(reviewQueueLoader) {
    this.setSRViewInFocus(true);
    this.focusObsidianWindow();
    new SRModalView(
      this.plugin.app,
      this.plugin,
      this.settingsManager,
      reviewQueueLoader
    ).open();
  }
  setSRViewInFocus(value) {
    this.isSRInFocus = value;
  }
  getSRInFocusState() {
    return this.isSRInFocus;
  }
  showRibbonIcon(status) {
    if (!this.ribbonIcon) {
      this.ribbonIcon = this.plugin.addRibbonIcon(
        "SpacedRepIcon",
        t("REVIEW_CARDS"),
        async () => {
          await this.openDeckContainer(1 /* Review */);
        }
      );
    }
    this.ribbonIcon.setCssProps({ display: status ? "" : "none" });
  }
  fileMenuHandler(menu, file) {
    if (!(file instanceof import_obsidian32.TFile && file.extension === "md")) return;
    const settings = this.settingsManager.settings;
    if (settings.showFileMenuReviewOptions) {
      menu.addItem((item) => {
        item.setTitle(
          t("REVIEW_DIFFICULTY_FILE_MENU", {
            difficulty: settings.flashcardEasyText
          })
        ).setIcon("SpacedRepIcon").onClick(() => {
          void this.plugin.dataManager.saveNoteReviewResponse(
            file,
            0 /* Easy */
          );
        });
      });
      menu.addItem((item) => {
        item.setTitle(
          t("REVIEW_DIFFICULTY_FILE_MENU", {
            difficulty: settings.flashcardGoodText
          })
        ).setIcon("SpacedRepIcon").onClick(() => {
          void this.plugin.dataManager.saveNoteReviewResponse(
            file,
            1 /* Good */
          );
        });
      });
      menu.addItem((item) => {
        item.setTitle(
          t("REVIEW_DIFFICULTY_FILE_MENU", {
            difficulty: settings.flashcardHardText
          })
        ).setIcon("SpacedRepIcon").onClick(() => {
          void this.plugin.dataManager.saveNoteReviewResponse(
            file,
            2 /* Hard */
          );
        });
      });
    }
    if (settings.showFileMenuReviewOptions && settings.showDeleteButtonInFileMenu) {
      menu.addSeparator();
    }
    if (settings.showDeleteButtonInFileMenu) {
      menu.addItem((item) => {
        item.setTitle(t("DELETE_NOTE_SCHEDULING_DATA_IN_NOTE")).setIcon("trash").setWarning(true).onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("DELETE_NOTE_SCHEDULING_DATA_IN_NOTE"),
            t("CONFIRM_NOTE_SCHEDULING_DATA_IN_NOTE_DELETION"),
            t("NOTE_SCHEDULING_DATA_IN_NOTE_DELETION_IN_PROGRESS"),
            async () => {
              const settings2 = this.settingsManager.settings;
              await DataStore.instance.fileModifier.deleteNoteSchedulingDataInNote(
                file,
                settings2.deleteTagsOnSchedulingDataDeletion,
                settings2.tagsToReview
              );
            }
          ).open();
        });
      });
      menu.addItem((item) => {
        item.setTitle(t("DELETE_SCHEDULING_DATA_OF_CARDS_IN_NOTE")).setIcon("trash").setWarning(true).onClick(() => {
          new ConfirmationModal(
            this.plugin.app,
            t("DELETE_SCHEDULING_DATA_OF_CARDS_IN_NOTE"),
            t("CONFIRM_SCHEDULING_DATA_OF_CARDS_IN_NOTE_DELETION"),
            t("SCHEDULING_DATA_OF_CARDS_IN_NOTE_DELETION_IN_PROGRESS"),
            async () => {
              const settings2 = this.settingsManager.settings;
              await DataStore.instance.fileModifier.deleteAllSchedulingDataOfCardsInNote(
                file,
                settings2.deleteTagsOnSchedulingDataDeletion,
                settings2.flashcardTags
              );
            }
          ).open();
        });
      });
    }
  }
};

// src/command-manager.ts
var CommandManager = class {
  constructor(plugin, settingsManager, uiManager) {
    this.plugin = plugin;
    this.settingsManager = settingsManager;
    this.uiManager = uiManager;
  }
  /**
   * register all the plugin commands once the plugin is loaded
   */
  onLayoutReady() {
    if (this.settingsManager.settings.useCustomHotkeys) {
      this.addCustomHotkeys();
    }
    this.addPluginCommands();
  }
  /**
   * remove all the plugin commands once the plugin is unloaded
   */
  onunload() {
    this.removeCustomHotkeys();
  }
  /**
   * remove all the hotkeys
   */
  removeCustomHotkeys() {
    this.plugin.removeCommand("srs-card-review-again");
    this.plugin.removeCommand("srs-card-review-hard");
    this.plugin.removeCommand("srs-card-review-good");
    this.plugin.removeCommand("srs-card-review-easy");
    this.plugin.removeCommand("srs-card-review-show-answer");
    this.plugin.removeCommand("srs-card-review-reset");
    this.plugin.removeCommand("srs-card-review-skip");
  }
  /**
   * add all the hotkeys
   */
  addCustomHotkeys() {
    this.plugin.addCommand({
      id: "srs-card-review-again",
      name: t("REVIEW_CARD_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardAgainText
      }),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 3 /* CardBack */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._processReview(3 /* Again */);
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-hard",
      name: t("REVIEW_CARD_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardHardText
      }),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 3 /* CardBack */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._processReview(2 /* Hard */);
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-good",
      name: t("REVIEW_CARD_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardGoodText
      }),
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 3 /* CardBack */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._processReview(1 /* Good */);
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-easy",
      name: t("REVIEW_CARD_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardEasyText
      }),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 3 /* CardBack */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._processReview(0 /* Easy */);
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-show-answer",
      name: t("SHOW_ANSWER"),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 2 /* CardFront */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._showAnswer();
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-skip",
      name: t("SKIP"),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && (this.uiManager.uiState === 3 /* CardBack */ || this.uiManager.uiState === 2 /* CardFront */) && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._skipCurrentCard();
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-reset",
      name: t("RESET_CARD_PROGRESS"),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 3 /* CardBack */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._processReview(4 /* Reset */);
          }
          return true;
        }
        return false;
      }
    });
    this.plugin.addCommand({
      id: "srs-card-review-reset",
      name: t("OPEN_IN_BACKGROUND"),
      repeatable: false,
      checkCallback: (checking) => {
        if (this.plugin.isInitialized && this.uiManager.uiState === 3 /* CardBack */ && this.uiManager.isSRInFocus && this.uiManager.contentManager !== null && !(import_obsidian33.Platform.isMobile || // No keyboard events on mobile
        EmulatedPlatform().isMobile) && !(activeDocument.activeElement !== null && (activeDocument.activeElement.nodeName === "TEXTAREA" || activeDocument.activeElement.nodeName === "INPUT"))) {
          if (!checking) {
            void this.uiManager.contentManager._jumpToCurrentCard();
          }
          return true;
        }
        return false;
      }
    });
  }
  /**
   * add all the plugin commands
   */
  addPluginCommands() {
    this.plugin.addCommand({
      id: "srs-note-review-open-note",
      name: t("OPEN_NOTE_FOR_REVIEW"),
      callback: async () => {
        if (!this.plugin.dataManager.syncLock && this.plugin.nextNoteReviewHandler !== null && this.plugin.isInitialized) {
          await this.plugin.dataManager.sync();
          await this.plugin.nextNoteReviewHandler.reviewNextNoteModal();
        }
      }
    });
    this.plugin.addCommand({
      id: "srs-note-review-easy",
      name: t("REVIEW_NOTE_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardEasyText
      }),
      repeatable: false,
      checkCallback: (checking) => {
        const openFile = this.plugin.app.workspace.getActiveFile();
        if (openFile === null || openFile.extension !== "md" || !this.plugin.isInitialized)
          return false;
        if (!checking) {
          void this.plugin.dataManager.saveNoteReviewResponse(
            openFile,
            0 /* Easy */
          );
        }
        return true;
      }
    });
    this.plugin.addCommand({
      id: "srs-note-review-good",
      name: t("REVIEW_NOTE_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardGoodText
      }),
      repeatable: false,
      checkCallback: (checking) => {
        const openFile = this.plugin.app.workspace.getActiveFile();
        if (openFile === null || openFile.extension !== "md" || !this.plugin.isInitialized)
          return false;
        if (!checking) {
          void this.plugin.dataManager.saveNoteReviewResponse(
            openFile,
            1 /* Good */
          );
        }
        return true;
      }
    });
    this.plugin.addCommand({
      id: "srs-note-review-hard",
      name: t("REVIEW_NOTE_DIFFICULTY_CMD", {
        difficulty: this.settingsManager.settings.flashcardHardText
      }),
      repeatable: false,
      checkCallback: (checking) => {
        const openFile = this.plugin.app.workspace.getActiveFile();
        if (openFile === null || openFile.extension !== "md" || !this.plugin.isInitialized)
          return false;
        if (!checking) {
          void this.plugin.dataManager.saveNoteReviewResponse(
            openFile,
            2 /* Hard */
          );
        }
        return true;
      }
    });
    this.plugin.addCommand({
      id: "srs-review-flashcards",
      name: t("REVIEW_ALL_CARDS"),
      callback: async () => {
        if (!this.plugin.isInitialized) return;
        await this.uiManager.openDeckContainer(1 /* Review */);
      }
    });
    this.plugin.addCommand({
      id: "srs-cram-flashcards",
      name: t("CRAM_ALL_CARDS"),
      callback: async () => {
        if (!this.plugin.isInitialized) return;
        await this.uiManager.openDeckContainer(0 /* Cram */);
      }
    });
    this.plugin.addCommand({
      id: "srs-review-flashcards-in-note",
      name: t("REVIEW_CARDS_IN_NOTE"),
      repeatable: false,
      checkCallback: (checking) => {
        const openFile = this.plugin.app.workspace.getActiveFile();
        if (openFile === null || openFile.extension !== "md" || !this.plugin.isInitialized)
          return false;
        if (!checking) {
          void this.uiManager.openDeckContainer(1 /* Review */, openFile);
        }
        return true;
      }
    });
    this.plugin.addCommand({
      id: "srs-cram-flashcards-in-note",
      name: t("CRAM_CARDS_IN_NOTE"),
      repeatable: false,
      checkCallback: (checking) => {
        const openFile = this.plugin.app.workspace.getActiveFile();
        if (openFile === null || openFile.extension !== "md" || !this.plugin.isInitialized)
          return false;
        if (!checking) {
          void this.uiManager.openDeckContainer(0 /* Cram */, openFile);
        }
        return true;
      }
    });
    this.plugin.addCommand({
      id: "srs-open-review-queue-view",
      name: t("OPEN_REVIEW_QUEUE_VIEW"),
      callback: async () => {
        if (!this.plugin.isInitialized) return;
        await this.uiManager.sidebarManager.openReviewQueueView();
      }
    });
  }
};

// src/data/data-manager.ts
var import_obsidian36 = require("obsidian");

// src/data/data-structures/deck/stats.ts
var Stats = class {
  constructor() {
    this.eases = new ValueCountDict();
    this.intervals = new ValueCountDict();
    this.delayedDays = new ValueCountDict();
    this.newCount = 0;
    this.youngCount = 0;
    this.matureCount = 0;
  }
  get totalCount() {
    return this.youngCount + this.matureCount;
  }
  incrementNew() {
    this.newCount++;
  }
  update(delayedDays, interval, ease) {
    this.intervals.incrementCount(interval);
    this.eases.incrementCount(ease);
    this.delayedDays.incrementCount(delayedDays);
    if (interval >= 32) {
      this.matureCount++;
    } else {
      this.youngCount++;
    }
  }
  getMaxInterval() {
    return this.intervals.getMaxValue();
  }
  getAverageInterval() {
    return this.intervals.getTotalOfValueMultiplyCount() / this.totalCount;
  }
  getAverageEases() {
    return this.eases.getTotalOfValueMultiplyCount() / this.totalCount;
  }
};

// src/data/data-structures/deck/deck-tree-stats-calculator.ts
var DeckTreeStatsCalculator = class {
  calculate(deckTree) {
    const iteratorOrder = {
      deckOrder: 0 /* PrevDeckComplete_Sequential */,
      repItemOrder: 2 /* DueFirstSequential */
    };
    const iterator = new DeckTreeIterator(iteratorOrder, deckTree.clone());
    const stats = new Stats();
    iterator.setIteratorTopicPath(TopicPath.emptyPath);
    while (iterator.nextRepItem()) {
      const card = iterator.currentRepItem;
      if (card === null) continue;
      if (card.scheduleInfo !== null) {
        const schedule = card.scheduleInfo;
        stats.update(
          schedule.delayedBeforeReviewDaysInt(),
          schedule.interval,
          schedule.latestEase
        );
      } else {
        stats.incrementNew();
      }
    }
    return stats;
  }
};

// src/note/note.ts
var Note = class {
  get hasChanged() {
    return this.questionList.some((question) => question.hasChanged);
  }
  get filePath() {
    return this.file.path;
  }
  constructor(file, questionList) {
    this.file = file;
    this.questionList = questionList;
    questionList.forEach((question) => question.note = this);
  }
  appendCardsToDeck(deck) {
    for (const question of this.questionList) {
      for (const card of question.cards) {
        deck.appendRepItem(question.topicPathList, card);
      }
    }
  }
  debugLogToConsole(desc = "") {
    var _a2;
    let str = `Note: ${desc}: ${this.questionList.length} questions\r
`;
    for (let i2 = 0; i2 < this.questionList.length; i2++) {
      const q2 = this.questionList[i2];
      str += `[${i2}]: ${q2.questionType}: ${q2.lineNo}: ${(_a2 = q2.topicPathList) == null ? void 0 : _a2.format("|")}: ${q2.questionText.original}\r
`;
    }
    console.debug(str);
  }
  async writeNoteFile(settings) {
    let fileText = await this.file.read();
    for (const question of this.questionList) {
      if (question.hasChanged) {
        fileText = question.updateQuestionWithinNoteText(fileText, settings);
      }
    }
    await this.file.write(fileText);
    this.questionList.forEach((question) => question.hasChanged = false);
  }
};

// src/data/data-store/base/rep-item-storage-info.ts
var RepItemStorageInfo = class {
  constructor(notePath, questionHash) {
    this.notePath = null;
    this.questionHash = null;
    this.notePath = notePath || null;
    this.questionHash = questionHash || null;
  }
};

// src/data/data-structures/card/questions/question-type.ts
var import_clozecraft2 = __toESM(require_dist());
var CardFrontBack = class {
  // The caller is responsible for any required trimming of leading/trailing spaces
  constructor(front, back) {
    this.front = front;
    this.back = back;
  }
};
var CardFrontBackUtil = class {
  static expand(questionType, questionText, settings) {
    const handler = QuestionTypeFactory.create(questionType);
    return handler.expand(questionText, settings);
  }
};
var QuestionTypeSingleLineBasic = class {
  expand(questionText, settings) {
    const idx = questionText.indexOf(settings.singleLineCardSeparator);
    const item = new CardFrontBack(
      questionText.substring(0, idx),
      questionText.substring(idx + settings.singleLineCardSeparator.length)
    );
    const result = [item];
    return result;
  }
};
var QuestionTypeSingleLineReversed = class {
  expand(questionText, settings) {
    const idx = questionText.indexOf(settings.singleLineReversedCardSeparator);
    const side1 = questionText.substring(0, idx), side2 = questionText.substring(
      idx + settings.singleLineReversedCardSeparator.length
    );
    const result = [
      new CardFrontBack(side1, side2),
      new CardFrontBack(side2, side1)
    ];
    return result;
  }
};
var QuestionTypeMultiLineBasic = class {
  expand(questionText, settings) {
    const questionLines = questionText.split("\n");
    const lineIdx = findLineIndexOfSearchStringIgnoringWs(
      questionLines,
      settings.multilineCardSeparator
    );
    const side1 = questionLines.slice(0, lineIdx).join("\n");
    const side2 = questionLines.slice(lineIdx + 1).join("\n");
    const result = [new CardFrontBack(side1, side2)];
    return result;
  }
};
var QuestionTypeMultiLineReversed = class {
  expand(questionText, settings) {
    const questionLines = questionText.split("\n");
    const lineIdx = findLineIndexOfSearchStringIgnoringWs(
      questionLines,
      settings.multilineReversedCardSeparator
    );
    const side1 = questionLines.slice(0, lineIdx).join("\n");
    const side2 = questionLines.slice(lineIdx + 1).join("\n");
    const result = [
      new CardFrontBack(side1, side2),
      new CardFrontBack(side2, side1)
    ];
    return result;
  }
};
var QuestionTypeCloze = class {
  expand(questionText, settings) {
    const clozecrafter = new import_clozecraft2.ClozeCrafter(settings.clozePatterns);
    const clozeNote = clozecrafter.createClozeNote(questionText);
    const clozeFormatter = settings.convertClozePatternsToInputs ? new QuestionTypeClozeInputFormatter() : new QuestionTypeClozeFormatter();
    let front, back;
    const result = [];
    if (clozeNote === null) return result;
    for (let i2 = 0; i2 < clozeNote.numCards; i2++) {
      front = clozeNote.getCardFront(i2, clozeFormatter);
      back = clozeNote.getCardBack(i2, clozeFormatter);
      result.push(new CardFrontBack(front, back));
    }
    return result;
  }
};
var QuestionTypeClozeFormatter = class {
  asking(_2, hint) {
    return `<span style='color:#2196f3'>${!hint ? "[...]" : `[${hint}]`}</span>`;
  }
  showingAnswer(answer, _2) {
    return `<span style='color:#2196f3'>${answer}</span>`;
  }
  hiding(_2, hint) {
    return `<span style='color:var(--code-comment)'>${!hint ? "[...]" : `[${hint}]`}</span>`;
  }
};
var QuestionTypeClozeInputFormatter = class {
  asking(answer, hint) {
    return `<span style='color:#2196f3'><input class="cloze-input" type="text" size="${!answer ? 1 : answer.length}" />${!hint ? "" : `[${hint}]`}</span>`;
  }
  showingAnswer(answer, _2) {
    return `<span class="cloze-answer" style='color:#2196f3'>${answer}</span>`;
  }
  hiding(_2, hint) {
    return `<span style='color:var(--code-comment)'>${!hint ? "[...]" : `[${hint}]`}</span>`;
  }
};
var QuestionTypeFactory = class {
  static create(questionType) {
    let handler;
    switch (questionType) {
      case 0 /* SingleLineBasic */:
        handler = new QuestionTypeSingleLineBasic();
        break;
      case 1 /* SingleLineReversed */:
        handler = new QuestionTypeSingleLineReversed();
        break;
      case 2 /* MultiLineBasic */:
        handler = new QuestionTypeMultiLineBasic();
        break;
      case 3 /* MultiLineReversed */:
        handler = new QuestionTypeMultiLineReversed();
        break;
      case 4 /* Cloze */:
        handler = new QuestionTypeCloze();
        break;
    }
    return handler;
  }
};

// src/data/data-structures/file/sr-file.ts
var import_obsidian34 = require("obsidian");
var frontmatterTagPseudoLineNum = -1;
var frontmatterTagPseudoCol = -1;
var frontmatterTagPseudoOffset = -1;
var SRTFile = class {
  // Reference to the Obsidian MetadataCache
  constructor(vault, metadataCache, fileManager, file) {
    this.vault = vault;
    this.metadataCache = metadataCache;
    this.file = file;
    this.fileManager = fileManager;
  }
  /**
   * Gets the path of the file.
   *
   * @returns {string} - The path of the file.
   */
  get path() {
    return this.file.path;
  }
  /**
   * Gets the basename of the file.
   *
   * @returns {string} - The basename of the file.
   */
  get basename() {
    return this.file.basename;
  }
  /**
   * Gets the Obsidian TFile.
   *
   * @returns {TFile} - The Obsidian TFile.
   */
  get tfile() {
    return this.file;
  }
  /**
   * Gets the frontmatter from the file cache.
   *
   * @returns {Promise<Map<string, string>>} - A promise that resolves with the frontmatter from the file.
   */
  async getFrontmatter() {
    const fileCachedData = this.metadataCache.getFileCache(this.file);
    if (!fileCachedData || !fileCachedData.frontmatter) {
      return /* @__PURE__ */ new Map();
    }
    const frontmatter = fileCachedData.frontmatter;
    const result = /* @__PURE__ */ new Map();
    for (const [key, value] of Object.entries(frontmatter)) {
      const v2 = Array.isArray(value) && value.length > 0 ? value[0] : value;
      const vStr = v2 + "";
      result.set(key, vStr);
    }
    return result;
  }
  /**
   * Gets all tags from the file cache.
   *
   * @returns {string[]} - An array of all tags from the file cache.
   */
  getAllTagsFromCache() {
    const fileCachedData = this.metadataCache.getFileCache(this.file);
    if (!fileCachedData) {
      return [];
    }
    const tags = (0, import_obsidian34.getAllTags)(fileCachedData) || [];
    return tags;
  }
  /**
   * Gets all tags from the text.
   *
   * @returns {TagCache[]} - An array of all tags from the text.
   */
  getAllTagsFromText() {
    const result = [];
    const fileCachedData = this.metadataCache.getFileCache(this.file);
    if (fileCachedData && fileCachedData.tags && fileCachedData.tags.length > 0) {
      result.push(...fileCachedData.tags);
    }
    if (fileCachedData && fileCachedData.frontmatter) {
      result.push(...this.getFrontmatterTags(fileCachedData.frontmatter));
    }
    if (result.length === 0) {
    }
    return result;
  }
  /**
   * Gets the tags from the frontmatter.
   *
   * @param {FrontMatterCache} frontmatter - The frontmatter from the file cache.
   * @returns {TagCache[]} - An array of tags from the frontmatter.
   */
  getFrontmatterTags(frontmatter) {
    const result = [];
    const frontmatterTags = frontmatter !== null && frontmatter !== void 0 ? frontmatter["tags"] + "" : null;
    if (!frontmatterTags) return result;
    const tagStrList = parseObsidianFrontmatterTag(frontmatterTags);
    for (const str of tagStrList) {
      const tag = {
        tag: str,
        position: {
          start: {
            line: frontmatterTagPseudoLineNum,
            col: frontmatterTagPseudoCol,
            offset: frontmatterTagPseudoOffset
          },
          end: {
            line: frontmatterTagPseudoLineNum,
            col: frontmatterTagPseudoCol,
            offset: frontmatterTagPseudoOffset
          }
        }
      };
      result.push(tag);
    }
    return result;
  }
  /**
   * Gets the text direction from the frontmatter.
   *
   * @returns {TextDirection} - The text direction from the frontmatter.
   */
  getTextDirection() {
    let result = 0 /* Unspecified */;
    const fileCache = this.metadataCache.getFileCache(this.file);
    const frontMatter = fileCache == null ? void 0 : fileCache.frontmatter;
    if (frontMatter && (frontMatter == null ? void 0 : frontMatter.direction)) {
      const str = (frontMatter.direction + "").toLowerCase();
      result = str === "rtl" ? 2 /* Rtl */ : 1 /* Ltr */;
    }
    return result;
  }
  /**
   * Reads the content of the file from the Obsidian vault.
   *
   * @returns {Promise<string>} - A promise that resolves with the content of the file.
   */
  async read() {
    return await this.vault.read(this.file);
  }
  /**
   * Writes the content to the file in the Obsidian vault.
   *
   * @param {string} content - The content to write to the file.
   * @returns {Promise<void>} - A promise that resolves when the content is written to the file.
   */
  async write(content) {
    await this.vault.modify(this.file, content);
  }
};

// src/note/note-question-parser.ts
var NoteQuestionParser = class {
  constructor(settings) {
    this.settings = settings;
  }
  async createQuestionList(noteFile, defaultTextDirection, folderTopicPath, onlyKeepQuestionsWithTopicPath) {
    this.noteFile = noteFile;
    const tagCacheList = noteFile.getAllTagsFromCache();
    const hasTopicPaths = tagCacheList.some((item) => SettingsUtil.isFlashcardTag(this.settings, item)) || folderTopicPath.hasPath;
    if (hasTopicPaths) {
      const noteText = await noteFile.read();
      const tagCompleteList = noteFile.getAllTagsFromText();
      [this.frontmatterText, this.contentText] = splitNoteIntoFrontmatterAndContent(noteText);
      let textDirection = noteFile.getTextDirection();
      if (textDirection === 0 /* Unspecified */) textDirection = defaultTextDirection;
      this.questionList = this.doCreateQuestionList(
        noteText,
        textDirection,
        folderTopicPath,
        this.tagCacheList
      );
      [this.frontmatterTopicPathList, this.contentTopicPathInfo] = this.analyseTagCacheList(tagCompleteList);
      for (const question of this.questionList) {
        question.topicPathList = this.determineQuestionTopicPathList(question);
      }
      if (onlyKeepQuestionsWithTopicPath) {
        this.questionList = this.questionList.filter((q2) => q2.topicPathList);
      }
    } else {
      this.questionList = [];
    }
    return this.questionList;
  }
  doCreateQuestionList(noteText, textDirection, folderTopicPath, tagCacheList) {
    this.noteText = noteText;
    this.noteLines = splitTextIntoLineArray(noteText);
    this.folderTopicPath = folderTopicPath;
    this.tagCacheList = tagCacheList;
    const result = [];
    const parsedQuestionInfoList = this.parseQuestions();
    for (const parsedQuestionInfo of parsedQuestionInfoList) {
      const question = this.createQuestionObject(parsedQuestionInfo, textDirection);
      const cardFrontBackList = CardFrontBackUtil.expand(
        question.questionType,
        question.questionText.actualQuestion,
        this.settings
      );
      let cardScheduleInfoList = DataStore.getInstance().createSchedule(
        question.questionText.original,
        new RepItemStorageInfo(this.noteFile.path, question.questionText.textHash)
      );
      const correctLength = cardFrontBackList.length;
      if (cardScheduleInfoList.length > correctLength) {
        question.hasChanged = true;
        cardScheduleInfoList = cardScheduleInfoList.slice(0, correctLength);
      }
      const cardList = this.createCardList(cardFrontBackList, cardScheduleInfoList);
      question.setCardList(cardList);
      result.push(question);
    }
    return result;
  }
  parseQuestions() {
    const settings = this.settings;
    const parserOptions = {
      singleLineCardSeparator: settings.singleLineCardSeparator,
      singleLineReversedCardSeparator: settings.singleLineReversedCardSeparator,
      multilineCardSeparator: settings.multilineCardSeparator,
      multilineReversedCardSeparator: settings.multilineReversedCardSeparator,
      multilineCardEndMarker: settings.multilineCardEndMarker,
      clozePatterns: settings.clozePatterns
    };
    return parse(this.contentText, parserOptions);
  }
  createQuestionObject(parsedQuestionInfo, textDirection) {
    const questionContext = this.noteFile.getQuestionContext(
      parsedQuestionInfo.firstLineNum
    );
    const result = Question.Create(
      this.settings,
      parsedQuestionInfo,
      null,
      // We haven't worked out the TopicPathList yet
      textDirection,
      questionContext
    );
    return result;
  }
  createCardList(cardFrontBackList, cardScheduleInfoList) {
    const siblings = [];
    for (let i2 = 0; i2 < cardFrontBackList.length; i2++) {
      const { front, back } = cardFrontBackList[i2];
      const hasScheduleInfo = i2 < cardScheduleInfoList.length;
      const schedule = cardScheduleInfoList[i2];
      const cardObj = new Card({
        front,
        back,
        cardIdx: i2
      });
      cardObj.scheduleInfo = hasScheduleInfo ? schedule : null;
      siblings.push(cardObj);
    }
    return siblings;
  }
  //
  // Given the complete list of tags within a note:
  // 1.   Only keep tags that are specified in the user settings as flashcardTags
  // 2.   Filter out tags that are question specific
  //      (these will be parsed separately by class QuestionText)
  // 3.   Combine all tags present logically grouped together into a single entry
  //      - All tags present on the same line grouped together
  //      - All tags within frontmatter grouped together (note that multiple tags
  //      within frontmatter appear on separate lines)
  //
  analyseTagCacheList(tagCacheList) {
    this.flashcardTagList = tagCacheList.filter(
      (item) => SettingsUtil.isFlashcardTag(this.settings, item.tag)
    );
    if (this.flashcardTagList.length > 0) {
      this.flashcardTagList.sort((a2, b2) => a2.position.start.line - b2.position.start.line);
    }
    let frontmatterLineCount = 0;
    if (this.frontmatterText) {
      frontmatterLineCount = splitTextIntoLineArray(this.frontmatterText).length;
    }
    const frontmatterTopicPathList = this.determineFrontmatterTopicPathList(this.flashcardTagList, frontmatterLineCount);
    const contentTopicPathList = this.determineContentTopicPathList(
      this.flashcardTagList,
      frontmatterLineCount
    );
    return [frontmatterTopicPathList, contentTopicPathList];
  }
  determineFrontmatterTopicPathList(flashcardTagList, frontmatterLineCount) {
    let result = null;
    const noteLevelTagList = flashcardTagList.filter(
      (item) => item.position.start.line === frontmatterTagPseudoLineNum && this.isNoteLevelFlashcardTag(item)
    );
    if (noteLevelTagList.length > 0) {
      if (this.frontmatterText) {
        const frontmatterTagCacheList = noteLevelTagList.filter(
          (item) => item.position.start.line < frontmatterLineCount
        );
        if (frontmatterTagCacheList.length > 0)
          result = this.createTopicPathList(
            frontmatterTagCacheList,
            frontmatterTagPseudoLineNum
          );
      }
    }
    return result;
  }
  determineContentTopicPathList(flashcardTagList, frontmatterLineCount) {
    const result = [];
    const contentStartLineNum = frontmatterLineCount;
    const contentTagCacheList = flashcardTagList.filter(
      (item) => item.position.start.line >= contentStartLineNum && this.isNoteLevelFlashcardTag(item)
    );
    let list = [];
    for (const tag of contentTagCacheList) {
      if (list.length !== 0) {
        const startLineNum = list[0].position.start.line;
        if (startLineNum !== tag.position.start.line) {
          result.push(this.createTopicPathList(list, startLineNum));
          list = [];
        }
      }
      list.push(tag);
    }
    if (list.length > 0) {
      const startLineNum = list[0].position.start.line;
      result.push(this.createTopicPathList(list, startLineNum));
    }
    return result;
  }
  isNoteLevelFlashcardTag(tagItem) {
    const tagLineNum = tagItem.position.start.line;
    const isQuestionSpecific = this.questionList.some(
      (q2) => q2.parsedQuestionInfo.isQuestionLineNum(tagLineNum)
    );
    return !isQuestionSpecific;
  }
  createTopicPathList(tagCacheList, lineNum) {
    const list = [];
    for (const tagCache of tagCacheList) {
      list.push(TopicPath.getTopicPathFromTag(tagCache.tag));
    }
    return new TopicPathList(list, lineNum);
  }
  createTopicPathListFromSingleTag(tagCache) {
    const list = [TopicPath.getTopicPathFromTag(tagCache.tag)];
    return new TopicPathList(list, tagCache.position.start.line);
  }
  // A question can be associated with multiple topics (hence returning TopicPathList and not just TopicPath).
  //
  // If the question has an associated question specific TopicPath, then that is returned.
  //
  // Else the first TopicPathList prior to the question (in the order present in the file) is returned.
  // That could be either the tags within the note's frontmatter, or tags on lines within the note's content.
  determineQuestionTopicPathList(question) {
    let result;
    if (this.settings.convertFoldersToDecks) {
      result = new TopicPathList([this.folderTopicPath]);
    } else {
      const questionText = question.questionText;
      if (questionText.topicPathWithWs)
        result = new TopicPathList(
          [questionText.topicPathWithWs.topicPath],
          question.parsedQuestionInfo.firstLineNum
        );
      else {
        result = this.frontmatterTopicPathList;
        for (let i2 = this.contentTopicPathInfo.length - 1; i2 >= 0; i2--) {
          const topicPathList = this.contentTopicPathInfo[i2];
          if (topicPathList.lineNum < question.parsedQuestionInfo.firstLineNum) {
            result = topicPathList;
            break;
          }
        }
        if (!result && this.flashcardTagList.length > 0) {
          result = this.createTopicPathListFromSingleTag(this.flashcardTagList[0]);
        }
      }
    }
    if (result === null) {
      console.log(
        "WARNING: No topic path list found. Please reload the deck list by closing and reopening the view"
      );
    }
    return result;
  }
};

// src/note/note-file-loader.ts
var NoteFileLoader = class {
  constructor(settings) {
    this.settings = settings;
  }
  async load(noteFile, defaultTextDirection, folderTopicPath) {
    this.noteFile = noteFile;
    const questionParser = new NoteQuestionParser(this.settings);
    const onlyKeepQuestionsWithTopicPath = true;
    const questionList = await questionParser.createQuestionList(
      noteFile,
      defaultTextDirection,
      folderTopicPath,
      onlyKeepQuestionsWithTopicPath
    );
    const result = new Note(noteFile, questionList);
    return result;
  }
};

// src/scheduling/algorithms/osr/osr-note-graph.ts
var graph = __toESM(require_lib());
var OsrNoteGraph = class {
  constructor(vaultNoteLinkInfoFinder) {
    // Key: targetFilename
    // Value: Map<sourceFilename, linkCount>
    // This is the number of links from sourceFilename to targetFilename
    // For simplicity, we just store the filename without the directory or filename extension
    this.incomingLinks = {};
    this.pageranks = {};
    this.vaultNoteLinkInfoFinder = vaultNoteLinkInfoFinder;
    this.reset();
  }
  reset() {
    this.incomingLinks = {};
    this.pageranks = {};
    graph.reset();
  }
  processLinks(path2) {
    if (this.incomingLinks[path2] === void 0) {
      this.incomingLinks[path2] = [];
    }
    const targetLinks = this.vaultNoteLinkInfoFinder.getResolvedTargetLinksForNotePath(path2) || {};
    for (const targetPath in targetLinks) {
      if (this.incomingLinks[targetPath] === void 0) this.incomingLinks[targetPath] = [];
      if (isSupportedFileType(targetPath)) {
        const linkCount = targetLinks[targetPath];
        this.incomingLinks[targetPath].push({
          sourcePath: path2,
          linkCount
        });
        graph.link(path2, targetPath, linkCount);
      }
    }
  }
  calcNoteLinkStat(notePath, noteEaseList) {
    let linkTotal = 0, linkPGTotal = 0, totalLinkCount = 0;
    for (const statObj of this.incomingLinks[notePath] || []) {
      const ease = noteEaseList.getEaseByPath(statObj.sourcePath);
      if (ease) {
        linkTotal += statObj.linkCount * this.pageranks[statObj.sourcePath] * ease;
        linkPGTotal += this.pageranks[statObj.sourcePath] * statObj.linkCount;
        totalLinkCount += statObj.linkCount;
      }
    }
    const outgoingLinks = this.vaultNoteLinkInfoFinder.getResolvedTargetLinksForNotePath(notePath) || {};
    for (const outgoingLink in outgoingLinks) {
      const ease = noteEaseList.getEaseByPath(outgoingLink);
      const linkCount = outgoingLinks[outgoingLink];
      const pageRank = this.pageranks[outgoingLink];
      if (ease) {
        linkTotal += linkCount * pageRank * ease;
        linkPGTotal += pageRank * linkCount;
        totalLinkCount += linkCount;
      }
    }
    return { linkTotal, linkPGTotal, totalLinkCount };
  }
  generatePageRanks() {
    graph.rank(0.85, 1e-6, (node, rank2) => {
      this.pageranks[node] = rank2 * 1e4;
    });
  }
};

// src/scheduling/due-date-histogram.ts
var _DueDateHistogram = class _DueDateHistogram {
  constructor(rec = null) {
    // Key - # of days in future
    // Value - Count of notes due
    this.dueDatesMap = /* @__PURE__ */ new Map();
    this.dueDatesMap = /* @__PURE__ */ new Map();
    if (rec !== null && rec !== void 0) {
      Object.entries(rec).forEach(([key, value]) => {
        this.dueDatesMap.set(Number(key), value);
      });
    }
  }
  get dueNotesCount() {
    let result = 0;
    if (this.dueDatesMap.has(_DueDateHistogram.dueNowNDays))
      result = this.dueDatesMap.get(_DueDateHistogram.dueNowNDays);
    return result;
  }
  hasEntryForDays(days) {
    return this.dueDatesMap.has(days);
  }
  set(days, value) {
    this.dueDatesMap.set(days, value);
  }
  get(days) {
    return this.dueDatesMap.get(days);
  }
  increment(days) {
    let value = 0;
    if (this.dueDatesMap.has(days)) {
      value = this.dueDatesMap.get(days);
    }
    this.dueDatesMap.set(days, value + 1);
  }
  decrement(days) {
    let value = 0;
    if (this.dueDatesMap.has(days)) value = this.dueDatesMap.get(days);
    if (value > 0) {
      this.dueDatesMap.set(days, value - 1);
    }
  }
  findLeastUsedIntervalOverRange(originalInterval, fuzz) {
    if (!this.hasEntryForDays(originalInterval)) {
      return originalInterval;
    }
    let interval = originalInterval;
    outer: for (let i2 = 1; i2 <= fuzz; i2++) {
      for (const ivl of [originalInterval - i2, originalInterval + i2]) {
        if (!this.hasEntryForDays(ivl)) {
          interval = ivl;
          break outer;
        }
        if (this.dueDatesMap.get(ivl) < this.dueDatesMap.get(interval)) interval = ivl;
      }
    }
    return interval;
  }
};
// The key for dueDatesNotes is the number of days after today
// therefore the key to lookup how many cards are due today is 0
_DueDateHistogram.dueNowNDays = 0;
var DueDateHistogram = _DueDateHistogram;
var NoteDueDateHistogram = class extends DueDateHistogram {
  calculateFromReviewDecksAndSort(reviewDecks, osrNoteGraph) {
    this.dueDatesMap = /* @__PURE__ */ new Map();
    const today = globalDateProvider.today.valueOf();
    reviewDecks.forEach((reviewDeck) => {
      reviewDeck.scheduledNotes.forEach((scheduledNote) => {
        const nDays = Math.ceil((scheduledNote.dueUnix - today) / TICKS_PER_DAY);
        this.increment(nDays);
      });
      reviewDeck.sortNotesByDateAndImportance(osrNoteGraph.pageranks);
    });
  }
};
var CardDueDateHistogram = class extends DueDateHistogram {
  calculateFromDeckTree(deckTree) {
    this.dueDatesMap = /* @__PURE__ */ new Map();
    const iteratorOrder = {
      deckOrder: 0 /* PrevDeckComplete_Sequential */,
      repItemOrder: 2 /* DueFirstSequential */
    };
    const now2 = globalDateProvider.now.valueOf();
    const iterator = new DeckTreeIterator(iteratorOrder, deckTree.clone());
    iterator.setIteratorTopicPath(TopicPath.emptyPath);
    while (iterator.nextRepItem()) {
      const card = iterator.currentRepItem;
      if (card.scheduleInfo && card.hasSchedule) {
        const scheduledCard = card.scheduleInfo;
        const nDays = Math.ceil(
          (scheduledCard.dueDateAsUnix - now2) / TICKS_PER_DAY
        );
        this.increment(nDays);
      }
    }
  }
};

// src/data/core.ts
var OsrCore = class {
  constructor(questionPostponementList, osrNoteLinkInfoFinder, settings, dataChangedHandler, noteReviewQueue, defaultTextDirection) {
    this.osrNoteGraph = null;
    this.fullDeckTree = null;
    this._reviewableDeckTree = new Deck("root", null);
    this._remainingDeckTree = null;
    this._cardStats = null;
    this.settings = settings;
    this.osrNoteLinkInfoFinder = osrNoteLinkInfoFinder;
    this.dataChangedHandler = dataChangedHandler;
    this._noteReviewQueue = noteReviewQueue;
    this._questionPostponementList = questionPostponementList;
    this._dueDateFlashcardHistogram = new CardDueDateHistogram();
    this._dueDateNoteHistogram = new NoteDueDateHistogram();
    this.defaultTextDirection = defaultTextDirection;
    try {
      const startOfDayElements = this.settings.startOfDay.split(":");
      if (startOfDayElements.length !== 3) {
        throw new Error("Invalid format for start of day");
      }
      const dayBoundary = {
        hour: parseInt(startOfDayElements[0]),
        minute: parseInt(startOfDayElements[1]),
        second: parseInt(startOfDayElements[2])
      };
      globalDateProvider.setDayBoundary(dayBoundary);
    } catch (e2) {
      console.warn("Invalid format for start of day", e2);
    }
  }
  /**
   * Initializes the OSR core for unit testing.
   *
   * @param {QuestionPostponementList} questionPostponementList - The question postponement list.
   * @param {IOsrVaultNoteLinkInfoFinder} osrNoteLinkInfoFinder - The OSR vault note link info finder.
   * @param {SRSettings} settings - The settings object.
   * @param {() => void} dataChangedHandler - A callback function that is called when the data has changed.
   * @param {NoteReviewQueue} noteReviewQueue - The note review queue.
   * @param {TextDirection} defaultTextDirection - The default text direction.
   * @returns {void}
   */
  initUnitTestCore(questionPostponementList, osrNoteLinkInfoFinder, settings, dataChangedHandler, noteReviewQueue, defaultTextDirection) {
    this.settings = settings;
    this.osrNoteLinkInfoFinder = osrNoteLinkInfoFinder;
    this.dataChangedHandler = dataChangedHandler;
    this._noteReviewQueue = noteReviewQueue;
    this._questionPostponementList = questionPostponementList;
    this._dueDateFlashcardHistogram = new CardDueDateHistogram();
    this._dueDateNoteHistogram = new NoteDueDateHistogram();
    this.defaultTextDirection = defaultTextDirection;
    try {
      const startOfDayElements = this.settings.startOfDay.split(":");
      if (startOfDayElements.length !== 3) {
        throw new Error("Invalid format for start of day");
      }
      const dayBoundary = {
        hour: parseInt(startOfDayElements[0]),
        minute: parseInt(startOfDayElements[1]),
        second: parseInt(startOfDayElements[2])
      };
      globalDateProvider.setDayBoundary(dayBoundary);
    } catch (e2) {
      console.warn("Invalid format for start of day", e2);
    }
  }
  /**
   * Gets the note review queue.
   *
   * @returns {NoteReviewQueue} - The note review queue.
   */
  get noteReviewQueue() {
    return this._noteReviewQueue;
  }
  /**
   * Gets the remaining deck tree.
   *
   * @returns {Deck} - The remaining deck tree.
   */
  get remainingDeckTree() {
    return this._remainingDeckTree;
  }
  /**
   * Gets the reviewable deck tree.
   *
   * @returns {Deck} - The reviewable deck tree.
   */
  get reviewableDeckTree() {
    return this._reviewableDeckTree;
  }
  /**
   * Gets the question postponement list.
   *
   * @returns {QuestionPostponementList} - The question postponement list.
   */
  get questionPostponementList() {
    return this._questionPostponementList;
  }
  /**
   * Gets the due date flashcard histogram.
   *
   * @returns {CardDueDateHistogram} - The due date flashcard histogram.
   */
  get dueDateFlashcardHistogram() {
    return this._dueDateFlashcardHistogram;
  }
  /**
   * Gets the due date note histogram.
   *
   * @returns {NoteDueDateHistogram} - The due date note histogram.
   */
  get dueDateNoteHistogram() {
    return this._dueDateNoteHistogram;
  }
  /**
   * Gets the card stats.
   *
   * @returns {Stats} - The card stats.
   */
  get cardStats() {
    return this._cardStats;
  }
  /**
   * Loads the initial state of the OSR core.
   *
   * @returns {void}
   */
  loadInitialStateOfCore() {
    this.osrNoteGraph = new OsrNoteGraph(this.osrNoteLinkInfoFinder);
    this._noteReviewQueue.init();
    this.fullDeckTree = new Deck("root", null);
  }
  /**
   * Processes a note file.
   *
   * @param {ISRNoteTFile} noteFile - The note file.
   * @returns {Promise<void>} - A promise that resolves when the note file is processed.
   */
  async processFile(noteFile) {
    const schedule = await this.readNoteSchedule(noteFile);
    let note = null;
    if (this.osrNoteGraph !== null) this.osrNoteGraph.processLinks(noteFile.path);
    const tags = noteFile.getAllTagsFromCache();
    const topicPath = this.findTopicPath(noteFile);
    if (topicPath.hasPath && !SettingsUtil.isAnyTagIgnoredForFlashcards(this.settings, tags)) {
      note = await this.loadNote(noteFile, topicPath);
      if (note !== null && this.fullDeckTree !== null)
        note.appendCardsToDeck(this.fullDeckTree);
    }
    if (schedule !== null) {
      SRAlgorithm.getInstance().noteOnLoadedNote(noteFile.path, note, schedule.latestEase);
    }
    const matchedNoteTags = SettingsUtil.filterForNoteReviewTag(this.settings, tags);
    if (matchedNoteTags.length === 0) {
      return;
    }
    if (SettingsUtil.isAnyTagIgnoredForNotes(this.settings, tags)) {
      return;
    }
    const noteSchedule = await this.readNoteSchedule(noteFile);
    this._noteReviewQueue.addNoteToQueue(noteFile, noteSchedule, matchedNoteTags);
  }
  /**
   * Reads the scheduling information for a note file.
   *
   * @param {ISRNoteTFile} noteFile - The note file.
   * @returns {Promise<RepItemScheduleInfo>} - A promise that resolves with the scheduling information for the note file.
   */
  async readNoteSchedule(noteFile) {
    return await noteFile.getNoteSchedule();
  }
  /**
   * Writes the scheduling information for a note file.
   *
   * @param {ISRNoteTFile} noteFile - The note file.
   * @param {RepItemScheduleInfo} noteSchedule - The scheduling information for the note file.
   * @returns {Promise<void>} - A promise that resolves when the scheduling information is written.
   */
  async writeNoteSchedule(noteFile, noteSchedule) {
    await noteFile.setNoteSchedule(noteSchedule);
  }
  /**
   * Finalizes the loading of the OSR core.
   *
   * @returns {void}
   */
  async finalizeLoad() {
    if (this.osrNoteGraph !== null) {
      this.osrNoteGraph.generatePageRanks();
    }
    if (this.fullDeckTree === null) {
      return;
    }
    this._reviewableDeckTree = this.fullDeckTree ? this.fullDeckTree.clone() : new Deck("root", null);
    this._reviewableDeckTree.sortSubdecksList();
    this._remainingDeckTree = DeckTreeFilter.filterForRemainingRepItems(
      this._questionPostponementList,
      this._reviewableDeckTree,
      1 /* Review */
    );
    const calc = new DeckTreeStatsCalculator();
    this._cardStats = calc.calculate(this._reviewableDeckTree);
    this.calculateDerivedInfo();
    this._dueDateFlashcardHistogram.calculateFromDeckTree(this._reviewableDeckTree);
    if (this.dataChangedHandler) await this.dataChangedHandler();
  }
  /**
   * Saves the review response for a note file.
   *
   * @param {ISRNoteTFile} noteFile - The note file.
   * @param {ReviewResponse} response - The review response.
   * @param {SRSettings} settings - The settings object.
   * @returns {Promise<void>} - A promise that resolves when the review response is saved.
   */
  async saveNoteReviewResponse(noteFile, response, settings) {
    const originalNoteSchedule = await this.readNoteSchedule(noteFile);
    let noteSchedule;
    if (originalNoteSchedule === null) {
      noteSchedule = SRAlgorithm.getInstance().noteCalcNewSchedule(
        noteFile.path,
        this.osrNoteGraph,
        response,
        this._dueDateNoteHistogram
      );
    } else {
      noteSchedule = SRAlgorithm.getInstance().noteCalcUpdatedSchedule(
        noteFile.path,
        originalNoteSchedule,
        response,
        this._dueDateNoteHistogram
      );
    }
    await this.writeNoteSchedule(noteFile, noteSchedule);
    this._noteReviewQueue.updateScheduleInfo(noteFile, noteSchedule);
    this.calculateDerivedInfo();
    await this.buryAllCardsInNote(settings, noteFile);
    if (this.dataChangedHandler) await this.dataChangedHandler();
  }
  /**
   * Calculates the derived information for the OSR core.
   *
   * @returns {void}
   */
  calculateDerivedInfo() {
    const todayUnix = globalDateProvider.today.valueOf();
    this.noteReviewQueue.calcDueNotesCount(todayUnix);
    this._dueDateNoteHistogram.calculateFromReviewDecksAndSort(
      this.noteReviewQueue.reviewDecks,
      this.osrNoteGraph
    );
  }
  /**
   * Buries all cards in a note.
   *
   * @param {SRSettings} settings - The settings object.
   * @param {ISRNoteTFile} noteFile - The note file.
   * @returns {Promise<void>} - A promise that resolves when the cards are buried.
   */
  async buryAllCardsInNote(settings, noteFile) {
    if (settings.burySiblingCards) {
      const topicPath = this.findTopicPath(noteFile);
      const noteX = await this.loadNote(noteFile, topicPath);
      if (noteX !== null && noteX.questionList.length > 0) {
        for (const question of noteX.questionList) {
          this._questionPostponementList.add(question);
        }
        await this._questionPostponementList.write();
      }
    }
  }
  /**
   * Loads a note from the Obsidian vault.
   *
   * @param {ISRNoteTFile} noteFile - The note file.
   * @param {TopicPath} topicPath - The topic path.
   * @returns {Promise<Note | null>} - A promise that resolves with the loaded note.
   */
  async loadNote(noteFile, topicPath) {
    const loader = new NoteFileLoader(this.settings);
    const note = await loader.load(noteFile, this.defaultTextDirection, topicPath);
    if (note !== null && note.hasChanged) {
      await note.writeNoteFile(this.settings);
    }
    return note;
  }
  /**
   * Finds the topic path for a note.
   *
   * @param {ISRNoteTFile} note - The note file.
   * @returns {TopicPath} - The topic path.
   */
  findTopicPath(note) {
    return TopicPath.getTopicPathOfFile(note, this.settings);
  }
};

// src/data/data-store/notes-data-store/note-data-file-modifier.ts
var import_obsidian35 = require("obsidian");
var NoteDataFileModifier = class {
  constructor(plugin) {
    this.plugin = plugin;
  }
  async migrateCommentsToCallouts() {
    const files = this.plugin.app.vault.getMarkdownFiles();
    for (let i2 = 0; i2 < files.length; i2++) {
      await this.migrateCommentsToCalloutsInFile(files[i2], this.plugin.app.vault);
    }
  }
  async migrateCommentsToCalloutsInFile(file, vault) {
    await vault.process(file, (data) => {
      let newData = "";
      const srCommentWithinMetadataRegex = /.*<!--SR:!.*-->/gm;
      const matches = data.matchAll(srCommentWithinMetadataRegex);
      let index = 0;
      for (const match2 of matches) {
        if (!match2[0].startsWith("> <!--SR:")) {
          const srComment = match2[0];
          const newText = `${match2.index !== 0 && data[match2.index - 1] === "\n" ? "" : "\n"}${SR_METADATA_CALLOUT}
> ${srComment}`;
          if (match2.index > index) {
            newData += data.substring(index, match2.index);
          }
          newData += newText;
          index = match2.index + srComment.length;
        }
      }
      if (index < data.length) {
        newData += data.substring(index);
      }
      return newData;
    });
  }
  migrateDataStore(_2) {
    return Promise.resolve();
  }
  /**
   * Deletes all note scheduling data from a markdown file.
   *
   * @param {Vault} vault - The vault to delete the scheduling data from.
   * @param {TFile} file - The file to delete the scheduling data from.
   */
  async removeSchedulingInfoInNotes(vault, file, deleteTags, tagsToDelete = []) {
    await this.plugin.app.fileManager.processFrontMatter(file, (frontmatter) => {
      delete frontmatter["sr-due"];
      delete frontmatter["sr-interval"];
      delete frontmatter["sr-ease"];
    });
    if (deleteTags) {
      await this.removeTagsFromFile(vault, file, tagsToDelete);
    }
  }
  async removeTagsFromFile(vault, file, tagsToDelete) {
    await this.removeTagsFromFrontmatter(vault, file, tagsToDelete);
    await vault.process(file, (data) => {
      let newData = data;
      for (const tagToDelete of tagsToDelete.sort((a2, b2) => b2.length - a2.length)) {
        const regex = new RegExp(
          // eslint-disable-next-line no-useless-escape
          `(${tagToDelete}[/[a-zA-z-[0-9]*]*/]*[a-zA-z-[0-9]*]*)`,
          "gm"
        );
        newData = newData.replace(regex, "");
        newData = newData.replace(tagToDelete, "");
      }
      return newData;
    });
  }
  async removeTagsFromFrontmatter(vault, file, tagsToDelete) {
    await this.plugin.app.fileManager.processFrontMatter(file, (frontmatter) => {
      frontmatter["tags"] = frontmatter["tags"].filter((tag) => {
        let deleteTag = false;
        for (const tagToDelete of tagsToDelete.sort((a2, b2) => b2.length - a2.length)) {
          if (tag.startsWith(tagToDelete.replace("#", ""))) {
            deleteTag = true;
            break;
          }
        }
        return !deleteTag;
      });
    });
  }
  /**
   * Deletes all card scheduling data from a markdown file.
   *
   * @param {Vault} vault - The vault to delete the scheduling data from.
   * @param {TFile} file - The file to delete the scheduling data from.
   */
  async removeSchedulingInfoInCards(vault, file, deleteTags, tagsToDelete = []) {
    await vault.process(file, (data) => {
      return data.replace(SR_COMMENT_AND_WHITESPACE_FINDER, "");
    });
    if (deleteTags) {
      await this.removeTagsFromFile(vault, file, tagsToDelete);
    }
  }
  /**
   * Deletes all scheduling data from all markdown files in the vault.
   */
  async deleteAllSchedulingData(deleteTags, deckTagsToDelete = [], noteTagsToDelete = []) {
    const files = this.plugin.app.vault.getMarkdownFiles();
    for (let i2 = 0; i2 < files.length; i2++) {
      await this.removeSchedulingInfoInNotes(
        this.plugin.app.vault,
        files[i2],
        deleteTags,
        noteTagsToDelete
      );
      await this.removeSchedulingInfoInCards(
        this.plugin.app.vault,
        files[i2],
        deleteTags,
        deckTagsToDelete
      );
    }
    new import_obsidian35.Notice(t("SCHEDULING_DATA_HAS_BEEN_DELETED"));
  }
  /**
   * Deletes all note scheduling data from all files in the vault.
   */
  async deleteAllSchedulingDataInNotes(deleteTags, tagsToDelete = []) {
    const files = this.plugin.app.vault.getMarkdownFiles();
    for (let i2 = 0; i2 < files.length; i2++) {
      await this.removeSchedulingInfoInNotes(
        this.plugin.app.vault,
        files[i2],
        deleteTags,
        tagsToDelete
      );
    }
    new import_obsidian35.Notice(t("SCHEDULING_DATA_HAS_BEEN_DELETED"));
  }
  /**
   * Deletes all card scheduling data from all files in the vault.
   */
  async deleteAllSchedulingDataInCards(deleteTags, tagsToDelete = []) {
    const files = this.plugin.app.vault.getMarkdownFiles();
    for (let i2 = 0; i2 < files.length; i2++) {
      await this.removeSchedulingInfoInCards(
        this.plugin.app.vault,
        files[i2],
        deleteTags,
        tagsToDelete
      );
    }
    new import_obsidian35.Notice(t("SCHEDULING_DATA_HAS_BEEN_DELETED"));
  }
  async deleteAllSchedulingDataOfCardsInNote(file, deleteTags, tagsToDelete) {
    await this.removeSchedulingInfoInCards(
      this.plugin.app.vault,
      file,
      deleteTags,
      tagsToDelete
    );
    new import_obsidian35.Notice(t("SCHEDULING_DATA_HAS_BEEN_DELETED"));
  }
  /**
   * Deletes all note scheduling data from all files in the vault.
   */
  async deleteNoteSchedulingDataInNote(file, deleteTags, tagsToDelete) {
    await this.removeSchedulingInfoInNotes(
      this.plugin.app.vault,
      file,
      deleteTags,
      tagsToDelete
    );
    new import_obsidian35.Notice(t("SCHEDULING_DATA_HAS_BEEN_DELETED"));
  }
};

// src/scheduling/algorithms/base/rep-item-schedule-info.ts
var RepItemScheduleInfo = class {
  constructor(algorithmType, dueDate, interval, latestEase, delayedBeforeReviewTicks) {
    this.dueDate = dueDate;
    this.interval = interval;
    this.latestEase = latestEase;
    this.delayedBeforeReviewTicks = delayedBeforeReviewTicks;
    this.algorithmType = algorithmType;
  }
  get dueDateAsUnix() {
    return this.dueDate.valueOf();
  }
  /**
   * Checks if the repetition item is due.
   *
   * @returns {boolean} - True if the repetition item is due, false otherwise.
   */
  isDue() {
    return this.dueDate && this.dueDate.isSameOrBefore(globalDateProvider.now);
  }
  /**
   * Formats the due date for the repetition item as a string.
   *
   * @returns {string} - The formatted due date.
   */
  formatDueDate() {
    return formatDate(this.dueDateAsUnix, PREFERRED_DATE_FORMAT);
  }
  /**
   * Formats the delayed before review ticks for the repetition item.
   *
   * @returns {number} - The formatted delayed before review ticks.
   */
  delayedBeforeReviewDaysInt() {
    return Math.max(0, Math.floor(this.delayedBeforeReviewTicks / TICKS_PER_DAY));
  }
};

// src/scheduling/algorithms/osr/rep-item-schedule-info-osr.ts
var _RepItemScheduleInfoOsr = class _RepItemScheduleInfoOsr extends RepItemScheduleInfo {
  constructor(dueDate, interval, latestEase, delayedBeforeReviewTicks = null) {
    super(
      "SM-2-OSR" /* SM_2_OSR */,
      dueDate,
      interval,
      latestEase,
      dueDate && delayedBeforeReviewTicks === null ? globalDateProvider.today.valueOf() - dueDate.valueOf() : delayedBeforeReviewTicks || 0
    );
  }
  static get initialInterval() {
    return 1;
  }
  /**
   * Formats the scheduling information for the repetition item as a string for HTML comments.
   *
   * @returns {string} - The formatted scheduling information for the repetition item as a string for HTML comments.
   */
  formatScheduleAsSRHtmlComment() {
    const dateStr = this.dueDate ? this.formatDueDate() : _RepItemScheduleInfoOsr.dummyDueDateForNewCard;
    return `!${dateStr},${this.interval},${this.latestEase}`;
  }
  /**
   * Gets a new schedule with the default values.
   *
   * @param {SRSettings} settings - The settings object.
   * @returns {RepItemScheduleInfoOsr} - A new schedule with the default values.
   */
  static getNewSchedule(settings) {
    return _RepItemScheduleInfoOsr.fromDueDateStr(
      _RepItemScheduleInfoOsr.dummyDueDateForNewCard,
      _RepItemScheduleInfoOsr.initialInterval,
      settings.baseEase
    );
  }
  /**
   * Creates a RepItemScheduleInfoOsr object from a due date string, interval, ease, and delayed before review ticks.
   *
   * @param {string} dueDateStr - The due date string.
   * @param {number} interval - The interval.
   * @param {number} ease - The ease.
   * @param {number | null} [delayedBeforeReviewTicks=null] - The delayed before review ticks.
   * @returns {RepItemScheduleInfoOsr} - The RepItemScheduleInfoOsr object.
   */
  static fromDueDateStr(dueDateStr, interval, ease, delayedBeforeReviewTicks = null) {
    const dueDate = DateUtil.dateStrToMoment(dueDateStr);
    return new _RepItemScheduleInfoOsr(dueDate, interval, ease, delayedBeforeReviewTicks);
  }
  /**
   * Formats the scheduling information for the repetition item as a JSON string.
   *
   * @returns {string} - The formatted scheduling information.
   */
  serializeSchedule() {
    const serializedData = {
      dueDate: this.dueDate ? formatDate(this.dueDateAsUnix, PREFERRED_DATE_FORMAT) : _RepItemScheduleInfoOsr.dummyDueDateForNewCard,
      interval: this.interval,
      ease: this.latestEase,
      delayedBeforeReviewTicks: this.delayedBeforeReviewTicks
    };
    return {
      algorithm: "SM-2-OSR" /* SM_2_OSR */,
      scheduleData: serializedData
    };
  }
};
// A question can have multiple cards. The schedule info for all sibling cards are formatted together
// in a single <!--SR: --> comment, such as:
// <!--SR:!2023-09-02,4,270!2023-09-02,5,270!2023-09-02,6,270!2023-09-02,7,270-->
//
// However, not all sibling cards may have been reviewed. Therefore we need a method of indicating that a particular card
// has not been reviewed, and should be considered "new"
// This is done by using this magic value for the date
_RepItemScheduleInfoOsr.dummyDueDateForNewCard = "2000-01-01";
var RepItemScheduleInfoOsr = _RepItemScheduleInfoOsr;

// src/data/data-store/notes-data-store/note-data-store-algorithm-osr.ts
var NoteDataStoreAlgorithmOsr = class {
  constructor(settings) {
    this.settings = settings;
  }
  questionFormatScheduleAsHtmlComment(question) {
    let accumulatedSchedules = "";
    for (let i2 = 0; i2 < question.cards.length; i2++) {
      const card = question.cards[i2];
      accumulatedSchedules += this.formatCardSchedule(card);
    }
    return SR_HTML_COMMENT_BEGIN + accumulatedSchedules + SR_HTML_COMMENT_END;
  }
  /**
   * Formats a card's scheduling information as a comment.
   *
   * It will return either the existing scheduling information or a default value if the card has no scheduling information.
   *
   * @param {Card} card - The card.
   * @returns {string} - The formatted card schedule.
   */
  formatCardSchedule(card) {
    if (card.hasSchedule && card.scheduleInfo) {
      return card.scheduleInfo.formatScheduleAsSRHtmlComment();
    }
    return `!${RepItemScheduleInfoOsr.dummyDueDateForNewCard},${RepItemScheduleInfoOsr.initialInterval},${this.settings.baseEase}`;
  }
};

// src/scheduling/algorithms/fsrs/fsrs-helpers.ts
var import_moment5 = __toESM(require_moment());

// node_modules/.pnpm/ts-fsrs@5.4.1/node_modules/ts-fsrs/dist/index.mjs
var FSRSError = class _FSRSError extends Error {
  constructor(message = "FSRS Error") {
    var _a2;
    super(message);
    this.name = "FSRSError";
    (_a2 = Error.captureStackTrace) == null ? void 0 : _a2.call(Error, this, _FSRSError);
  }
};
var FSRSValidationError = class _FSRSValidationError extends FSRSError {
  constructor(message) {
    var _a2;
    super(message);
    this.name = "FSRSValidationError";
    (_a2 = Error.captureStackTrace) == null ? void 0 : _a2.call(Error, this, _FSRSValidationError);
  }
};
var State = /* @__PURE__ */ ((State2) => {
  State2[State2["New"] = 0] = "New";
  State2[State2["Learning"] = 1] = "Learning";
  State2[State2["Review"] = 2] = "Review";
  State2[State2["Relearning"] = 3] = "Relearning";
  return State2;
})(State || {});
var Rating = /* @__PURE__ */ ((Rating2) => {
  Rating2[Rating2["Manual"] = 0] = "Manual";
  Rating2[Rating2["Again"] = 1] = "Again";
  Rating2[Rating2["Hard"] = 2] = "Hard";
  Rating2[Rating2["Good"] = 3] = "Good";
  Rating2[Rating2["Easy"] = 4] = "Easy";
  return Rating2;
})(Rating || {});
var TypeConvert = class _TypeConvert {
  static card(card) {
    return {
      ...card,
      state: _TypeConvert.state(card.state),
      due: _TypeConvert.time(card.due),
      last_review: card.last_review ? _TypeConvert.time(card.last_review) : void 0
    };
  }
  static rating(value) {
    if (typeof value === "string") {
      const firstLetter = value.charAt(0).toUpperCase();
      const restOfString = value.slice(1).toLowerCase();
      const ret = Rating[`${firstLetter}${restOfString}`];
      if (ret === void 0) {
        throw new FSRSValidationError(`Invalid rating:[${value}]`);
      }
      return ret;
    } else if (typeof value === "number") {
      return value;
    }
    throw new FSRSValidationError(`Invalid rating:[${value}]`);
  }
  static state(value) {
    if (typeof value === "string") {
      const firstLetter = value.charAt(0).toUpperCase();
      const restOfString = value.slice(1).toLowerCase();
      const ret = State[`${firstLetter}${restOfString}`];
      if (ret === void 0) {
        throw new FSRSValidationError(`Invalid state:[${value}]`);
      }
      return ret;
    } else if (typeof value === "number") {
      return value;
    }
    throw new FSRSValidationError(`Invalid state:[${value}]`);
  }
  static time(value) {
    if (value instanceof Date) {
      return value;
    }
    const date = new Date(value);
    if (typeof value === "object" && value !== null && !Number.isNaN(Date.parse(value) || +date)) {
      return date;
    } else if (typeof value === "string") {
      const timestamp = Date.parse(value);
      if (!Number.isNaN(timestamp)) {
        return new Date(timestamp);
      } else {
        throw new FSRSValidationError(`Invalid date:[${value}]`);
      }
    } else if (typeof value === "number") {
      return new Date(value);
    }
    throw new FSRSValidationError(`Invalid date:[${value}]`);
  }
  static review_log(log) {
    return {
      ...log,
      due: _TypeConvert.time(log.due),
      rating: _TypeConvert.rating(log.rating),
      state: _TypeConvert.state(log.state),
      review: _TypeConvert.time(log.review)
    };
  }
};
Date.prototype.scheduler = function(t3, isDay) {
  return date_scheduler(this, t3, isDay);
};
Date.prototype.diff = function(pre, unit) {
  return date_diff(this, pre, unit);
};
Date.prototype.format = function() {
  return formatDate2(this);
};
Date.prototype.dueFormat = function(last_review, unit, timeUnit) {
  return show_diff_message(this, last_review, unit, timeUnit);
};
function date_scheduler(now2, t3, isDay) {
  return new Date(
    isDay ? TypeConvert.time(now2).getTime() + t3 * 24 * 60 * 60 * 1e3 : TypeConvert.time(now2).getTime() + t3 * 60 * 1e3
  );
}
function date_diff(now2, pre, unit) {
  if (!now2 || !pre) {
    throw new FSRSValidationError("Invalid date");
  }
  const diff = TypeConvert.time(now2).getTime() - TypeConvert.time(pre).getTime();
  let r2 = 0;
  switch (unit) {
    case "days":
      r2 = Math.floor(diff / (24 * 60 * 60 * 1e3));
      break;
    case "minutes":
      r2 = Math.floor(diff / (60 * 1e3));
      break;
  }
  return r2;
}
function formatDate2(dateInput) {
  const date = TypeConvert.time(dateInput);
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();
  const hours = date.getHours();
  const minutes = date.getMinutes();
  const seconds = date.getSeconds();
  return `${year}-${padZero(month)}-${padZero(day)} ${padZero(hours)}:${padZero(
    minutes
  )}:${padZero(seconds)}`;
}
function padZero(num) {
  return num < 10 ? `0${num}` : `${num}`;
}
var TIMEUNIT = [60, 60, 24, 31, 12];
var TIMEUNITFORMAT = ["second", "min", "hour", "day", "month", "year"];
function show_diff_message(due, last_review, unit, timeUnit = TIMEUNITFORMAT) {
  due = TypeConvert.time(due);
  last_review = TypeConvert.time(last_review);
  if (timeUnit.length !== TIMEUNITFORMAT.length) {
    timeUnit = TIMEUNITFORMAT;
  }
  let diff = due.getTime() - last_review.getTime();
  let i2 = 0;
  diff /= 1e3;
  for (i2 = 0; i2 < TIMEUNIT.length; i2++) {
    if (diff < TIMEUNIT[i2]) {
      break;
    } else {
      diff /= TIMEUNIT[i2];
    }
  }
  return `${Math.floor(diff)}${unit ? timeUnit[i2] : ""}`;
}
var Grades = Object.freeze([
  Rating.Again,
  Rating.Hard,
  Rating.Good,
  Rating.Easy
]);
var FUZZ_RANGES = [
  {
    start: 2.5,
    end: 7,
    factor: 0.15
  },
  {
    start: 7,
    end: 20,
    factor: 0.1
  },
  {
    start: 20,
    end: Infinity,
    factor: 0.05
  }
];
function get_fuzz_range(interval, elapsed_days, maximum_interval) {
  let delta = 1;
  for (const range2 of FUZZ_RANGES) {
    delta += range2.factor * Math.max(Math.min(interval, range2.end) - range2.start, 0);
  }
  interval = Math.min(interval, maximum_interval);
  let min_ivl = Math.max(2, Math.round(interval - delta));
  const max_ivl = Math.min(Math.round(interval + delta), maximum_interval);
  if (interval > elapsed_days) {
    min_ivl = Math.max(min_ivl, elapsed_days + 1);
  }
  min_ivl = Math.min(min_ivl, max_ivl);
  return { min_ivl, max_ivl };
}
function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max);
}
function roundTo(num, decimals) {
  const factor = 10 ** decimals;
  return Math.round(num * factor) / factor;
}
function dateDiffInDays(last, cur) {
  const utc1 = Date.UTC(
    last.getUTCFullYear(),
    last.getUTCMonth(),
    last.getUTCDate()
  );
  const utc2 = Date.UTC(
    cur.getUTCFullYear(),
    cur.getUTCMonth(),
    cur.getUTCDate()
  );
  return Math.floor(
    (utc2 - utc1) / 864e5
    /** 1000 * 60 * 60 * 24*/
  );
}
var ConvertStepUnitToMinutes = (step) => {
  const unit = step.slice(-1);
  const value = parseInt(step.slice(0, -1), 10);
  if (Number.isNaN(value) || !Number.isFinite(value) || value < 0) {
    throw new FSRSValidationError(`Invalid step value: ${step}`);
  }
  switch (unit) {
    case "m":
      return value;
    case "h":
      return value * 60;
    case "d":
      return value * 1440;
    default:
      throw new FSRSValidationError(
        `Invalid step unit: ${step}, expected m/h/d`
      );
  }
};
var BasicLearningStepsStrategy = (params, state, cur_step) => {
  const learning_steps = state === State.Relearning || state === State.Review ? params.relearning_steps : params.learning_steps;
  const steps_length = learning_steps.length;
  if (steps_length === 0 || cur_step >= steps_length) return {};
  const firstStep = learning_steps[0];
  const toMinutes = ConvertStepUnitToMinutes;
  const getAgainInterval = () => {
    return toMinutes(firstStep);
  };
  const getHardInterval = () => {
    if (steps_length === 1) return Math.round(toMinutes(firstStep) * 1.5);
    const nextStep = learning_steps[1];
    return Math.round((toMinutes(firstStep) + toMinutes(nextStep)) / 2);
  };
  const getStepInfo = (index) => {
    if (index < 0 || index >= steps_length) {
      return null;
    } else {
      return learning_steps[index];
    }
  };
  const getGoodMinutes = (step) => {
    return toMinutes(step);
  };
  const result = {};
  const step_info = getStepInfo(Math.max(0, cur_step));
  if (state === State.Review) {
    result[Rating.Again] = {
      scheduled_minutes: toMinutes(step_info),
      next_step: 0
    };
    return result;
  } else {
    result[Rating.Again] = {
      scheduled_minutes: getAgainInterval(),
      next_step: 0
    };
    result[Rating.Hard] = {
      scheduled_minutes: getHardInterval(),
      next_step: cur_step
    };
    const next_info = getStepInfo(cur_step + 1);
    if (next_info) {
      const nextMin = getGoodMinutes(next_info);
      if (nextMin) {
        result[Rating.Good] = {
          scheduled_minutes: Math.round(nextMin),
          next_step: cur_step + 1
        };
      }
    }
  }
  return result;
};
function DefaultInitSeedStrategy() {
  const time = this.review_time.getTime();
  const reps = this.current.reps;
  const mul = this.current.difficulty * this.current.stability;
  return `${time}_${reps}_${mul}`;
}
var StrategyMode = /* @__PURE__ */ ((StrategyMode2) => {
  StrategyMode2["SCHEDULER"] = "Scheduler";
  StrategyMode2["LEARNING_STEPS"] = "LearningSteps";
  StrategyMode2["SEED"] = "Seed";
  return StrategyMode2;
})(StrategyMode || {});
var AbstractScheduler = class {
  // init
  constructor(card, now2, algorithm, strategies) {
    __publicField(this, "last");
    __publicField(this, "current");
    __publicField(this, "review_time");
    __publicField(this, "next", /* @__PURE__ */ new Map());
    __publicField(this, "algorithm");
    __publicField(this, "strategies");
    __publicField(this, "elapsed_days", 0);
    this.algorithm = algorithm;
    this.last = TypeConvert.card(card);
    this.current = TypeConvert.card(card);
    this.review_time = TypeConvert.time(now2);
    this.strategies = strategies;
    this.init();
  }
  checkGrade(grade) {
    if (!Number.isFinite(grade) || grade < 1 || grade > 4) {
      throw new FSRSValidationError(`Invalid grade "${grade}",expected 1-4`);
    }
  }
  init() {
    const { state, last_review } = this.current;
    let interval = 0;
    if (state !== State.New && last_review) {
      interval = dateDiffInDays(last_review, this.review_time);
    }
    this.current.last_review = this.review_time;
    this.elapsed_days = interval;
    this.current.elapsed_days = interval;
    this.current.reps += 1;
    let seed_strategy = DefaultInitSeedStrategy;
    if (this.strategies) {
      const custom_strategy = this.strategies.get(StrategyMode.SEED);
      if (custom_strategy) {
        seed_strategy = custom_strategy;
      }
    }
    this.algorithm.seed = seed_strategy.call(this);
  }
  preview() {
    return {
      [Rating.Again]: this.review(Rating.Again),
      [Rating.Hard]: this.review(Rating.Hard),
      [Rating.Good]: this.review(Rating.Good),
      [Rating.Easy]: this.review(Rating.Easy),
      [Symbol.iterator]: this.previewIterator.bind(this)
    };
  }
  *previewIterator() {
    for (const grade of Grades) {
      yield this.review(grade);
    }
  }
  review(grade) {
    const { state } = this.last;
    let item;
    this.checkGrade(grade);
    switch (state) {
      case State.New:
        item = this.newState(grade);
        break;
      case State.Learning:
      case State.Relearning:
        item = this.learningState(grade);
        break;
      case State.Review:
        item = this.reviewState(grade);
        break;
    }
    return item;
  }
  buildLog(rating) {
    const { last_review, due, elapsed_days } = this.last;
    return {
      rating,
      state: this.current.state,
      due: last_review || due,
      stability: this.current.stability,
      difficulty: this.current.difficulty,
      elapsed_days: this.elapsed_days,
      last_elapsed_days: elapsed_days,
      scheduled_days: this.current.scheduled_days,
      learning_steps: this.current.learning_steps,
      review: this.review_time
    };
  }
};
var Alea = class {
  constructor(seed) {
    __publicField(this, "c");
    __publicField(this, "s0");
    __publicField(this, "s1");
    __publicField(this, "s2");
    const mash = Mash();
    this.c = 1;
    this.s0 = mash(" ");
    this.s1 = mash(" ");
    this.s2 = mash(" ");
    if (seed == null) seed = Date.now();
    this.s0 -= mash(seed);
    if (this.s0 < 0) this.s0 += 1;
    this.s1 -= mash(seed);
    if (this.s1 < 0) this.s1 += 1;
    this.s2 -= mash(seed);
    if (this.s2 < 0) this.s2 += 1;
  }
  next() {
    const t3 = 2091639 * this.s0 + this.c * 23283064365386963e-26;
    this.s0 = this.s1;
    this.s1 = this.s2;
    this.c = t3 | 0;
    this.s2 = t3 - this.c;
    return this.s2;
  }
  set state(state) {
    this.c = state.c;
    this.s0 = state.s0;
    this.s1 = state.s1;
    this.s2 = state.s2;
  }
  get state() {
    return {
      c: this.c,
      s0: this.s0,
      s1: this.s1,
      s2: this.s2
    };
  }
};
function Mash() {
  let n2 = 4022871197;
  return function mash(data) {
    data = String(data);
    for (let i2 = 0; i2 < data.length; i2++) {
      n2 += data.charCodeAt(i2);
      let h3 = 0.02519603282416938 * n2;
      n2 = h3 >>> 0;
      h3 -= n2;
      h3 *= n2;
      n2 = h3 >>> 0;
      h3 -= n2;
      n2 += h3 * 4294967296;
    }
    return (n2 >>> 0) * 23283064365386963e-26;
  };
}
function alea(seed) {
  const xg = new Alea(seed);
  const prng = () => xg.next();
  prng.int32 = () => xg.next() * 4294967296 | 0;
  prng.double = () => prng() + (prng() * 2097152 | 0) * 11102230246251565e-32;
  prng.state = () => xg.state;
  prng.importState = (state) => {
    xg.state = state;
    return prng;
  };
  return prng;
}
var version2 = "5.4.1";
var default_request_retention = 0.9;
var default_maximum_interval = 36500;
var default_enable_fuzz = false;
var default_enable_short_term = true;
var default_learning_steps = Object.freeze([
  "1m",
  "10m"
]);
var default_relearning_steps = Object.freeze([
  "10m"
]);
var FSRSVersion = `v${version2} using FSRS-6.0`;
var S_MIN = 1e-3;
var INIT_S_MAX = 100;
var FSRS5_DEFAULT_DECAY = 0.5;
var FSRS6_DEFAULT_DECAY = 0.1542;
var default_w = Object.freeze([
  0.212,
  1.2931,
  2.3065,
  8.2956,
  6.4133,
  0.8334,
  3.0194,
  1e-3,
  1.8722,
  0.1666,
  0.796,
  1.4835,
  0.0614,
  0.2629,
  1.6483,
  0.6014,
  1.8729,
  0.5425,
  0.0912,
  0.0658,
  FSRS6_DEFAULT_DECAY
]);
var W17_W18_Ceiling = 2;
var CLAMP_PARAMETERS = (w17_w18_ceiling, enable_short_term = default_enable_short_term) => [
  [S_MIN, INIT_S_MAX],
  [S_MIN, INIT_S_MAX],
  [S_MIN, INIT_S_MAX],
  [S_MIN, INIT_S_MAX],
  [1, 10],
  [1e-3, 4],
  [1e-3, 4],
  [1e-3, 0.75],
  [0, 4.5],
  [0, 0.8],
  [1e-3, 3.5],
  [1e-3, 5],
  [1e-3, 0.25],
  [1e-3, 0.9],
  [0, 4],
  [0, 1],
  [1, 6],
  [0, w17_w18_ceiling],
  [0, w17_w18_ceiling],
  [
    enable_short_term ? 0.01 : 0,
    0.8
  ],
  [0.1, 0.8]
];
var clipParameters = (parameters, numRelearningSteps, enableShortTerm = default_enable_short_term) => {
  const clip = CLAMP_PARAMETERS(W17_W18_Ceiling, enableShortTerm).slice(
    0,
    parameters.length
  );
  if (Math.max(0, numRelearningSteps) > 1) {
    const w11 = clamp(parameters[11] || 0, clip[11][0], clip[11][1]);
    const w13 = clamp(parameters[13] || 0, clip[13][0], clip[13][1]);
    const w14 = clamp(parameters[14] || 0, clip[14][0], clip[14][1]);
    const value = -(Math.log(w11) + Math.log(Math.pow(2, w13) - 1) + w14 * 0.3) / numRelearningSteps;
    const w17_w18_ceiling = clamp(
      roundTo(Math.sqrt(Math.max(value, 0)), 8),
      0.01,
      W17_W18_Ceiling
    );
    if (clip[17]) clip[17] = [clip[17][0], w17_w18_ceiling];
    if (clip[18]) clip[18] = [clip[18][0], w17_w18_ceiling];
  }
  return clip.map(
    ([min, max], index) => clamp(parameters[index] || 0, min, max)
  );
};
var migrateParameters = (parameters, numRelearningSteps = 0, enableShortTerm = default_enable_short_term) => {
  if (parameters === void 0) {
    return [...default_w];
  }
  switch (parameters.length) {
    case 21:
      return clipParameters(
        Array.from(parameters),
        numRelearningSteps,
        enableShortTerm
      );
    case 19:
      console.debug("[FSRS-6]auto fill w from 19 to 21 length");
      return clipParameters(
        Array.from(parameters),
        numRelearningSteps,
        enableShortTerm
      ).concat([0, FSRS5_DEFAULT_DECAY]);
    case 17: {
      const w2 = clipParameters(
        Array.from(parameters),
        numRelearningSteps,
        enableShortTerm
      );
      w2[4] = +(w2[5] * 2 + w2[4]).toFixed(8);
      w2[5] = +(Math.log(w2[5] * 3 + 1) / 3).toFixed(8);
      w2[6] = +(w2[6] + 0.5).toFixed(8);
      console.debug("[FSRS-6]auto fill w from 17 to 21 length");
      return w2.concat([0, 0, 0, FSRS5_DEFAULT_DECAY]);
    }
    default:
      console.warn("[FSRS]Invalid parameters length, using default parameters");
      return [...default_w];
  }
};
var generatorParameters = (props) => {
  var _a2, _b;
  const learning_steps = Array.isArray(props == null ? void 0 : props.learning_steps) ? props.learning_steps : default_learning_steps;
  const relearning_steps = Array.isArray(props == null ? void 0 : props.relearning_steps) ? props.relearning_steps : default_relearning_steps;
  const enable_short_term = (_a2 = props == null ? void 0 : props.enable_short_term) != null ? _a2 : default_enable_short_term;
  const w2 = migrateParameters(
    props == null ? void 0 : props.w,
    relearning_steps.length,
    enable_short_term
  );
  return {
    request_retention: (props == null ? void 0 : props.request_retention) || default_request_retention,
    maximum_interval: (props == null ? void 0 : props.maximum_interval) || default_maximum_interval,
    w: w2,
    enable_fuzz: (_b = props == null ? void 0 : props.enable_fuzz) != null ? _b : default_enable_fuzz,
    enable_short_term,
    learning_steps,
    relearning_steps
  };
};
function createEmptyCard(now2, afterHandler) {
  const emptyCard = {
    due: now2 ? TypeConvert.time(now2) : /* @__PURE__ */ new Date(),
    stability: 0,
    difficulty: 0,
    elapsed_days: 0,
    scheduled_days: 0,
    reps: 0,
    lapses: 0,
    learning_steps: 0,
    state: State.New,
    last_review: void 0
  };
  if (afterHandler && typeof afterHandler === "function") {
    return afterHandler(emptyCard);
  } else {
    return emptyCard;
  }
}
var computeDecayFactor = (decayOrParams) => {
  const decay = typeof decayOrParams === "number" ? -decayOrParams : -decayOrParams[20];
  const factor = Math.exp(Math.pow(decay, -1) * Math.log(0.9)) - 1;
  return { decay, factor: roundTo(factor, 8) };
};
function forgetting_curve(decayOrParams, elapsed_days, stability) {
  const { decay, factor } = computeDecayFactor(decayOrParams);
  return roundTo(Math.pow(1 + factor * elapsed_days / stability, decay), 8);
}
var FSRSAlgorithm = class {
  constructor(params) {
    __publicField(this, "param");
    __publicField(this, "intervalModifier");
    __publicField(this, "_seed");
    /**
     * The formula used is :
     * $$R(t,S) = (1 + \text{FACTOR} \times \frac{t}{9 \cdot S})^{\text{DECAY}}$$
     * @param {number} elapsed_days t days since the last review
     * @param {number} stability Stability (interval when R=90%)
     * @return {number} r Retrievability (probability of recall)
     */
    __publicField(this, "forgetting_curve");
    this.param = new Proxy(
      generatorParameters(params),
      this.params_handler_proxy()
    );
    this.intervalModifier = this.calculate_interval_modifier(
      this.param.request_retention
    );
    this.forgetting_curve = forgetting_curve.bind(this, this.param.w);
  }
  get interval_modifier() {
    return this.intervalModifier;
  }
  set seed(seed) {
    this._seed = seed;
  }
  /**
   * @see https://github.com/open-spaced-repetition/fsrs4anki/wiki/The-Algorithm#fsrs-5
   *
   * The formula used is: $$I(r,s) = (r^{\frac{1}{DECAY}} - 1) / FACTOR \times s$$
   * @param request_retention 0<request_retention<=1,Requested retention rate
   * @throws {Error} Requested retention rate should be in the range (0,1]
   */
  calculate_interval_modifier(request_retention) {
    if (request_retention <= 0 || request_retention > 1) {
      throw new FSRSValidationError(
        "Requested retention rate should be in the range (0,1]"
      );
    }
    const { decay, factor } = computeDecayFactor(this.param.w);
    return roundTo((Math.pow(request_retention, 1 / decay) - 1) / factor, 8);
  }
  /**
   * Get the parameters of the algorithm.
   */
  get parameters() {
    return this.param;
  }
  /**
   * Set the parameters of the algorithm.
   * @param params Partial<FSRSParameters>
   */
  set parameters(params) {
    this.update_parameters(params);
  }
  params_handler_proxy() {
    const _this = this;
    return {
      set: function(target, prop, value) {
        if (prop === "request_retention" && Number.isFinite(value)) {
          _this.intervalModifier = _this.calculate_interval_modifier(
            Number(value)
          );
        } else if (prop === "w") {
          value = migrateParameters(
            value,
            target.relearning_steps.length,
            target.enable_short_term
          );
          _this.forgetting_curve = forgetting_curve.bind(this, value);
          _this.intervalModifier = _this.calculate_interval_modifier(
            Number(target.request_retention)
          );
        }
        Reflect.set(target, prop, value);
        return true;
      }
    };
  }
  update_parameters(params) {
    const _params = generatorParameters(params);
    for (const key in _params) {
      const paramKey = key;
      this.param[paramKey] = _params[paramKey];
    }
  }
  /**
     * The formula used is :
     * $$ S_0(G) = w_{G-1}$$
     * $$S_0 = \max \lbrace S_0,0.1\rbrace $$
  
     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
     * @return Stability (interval when R=90%)
     */
  init_stability(g2) {
    return Math.max(this.param.w[g2 - 1], 0.1);
  }
  /**
   * The formula used is :
   * $$D_0(G) = w_4 - e^{(G-1) \cdot w_5} + 1 $$
   * $$D_0 = \min \lbrace \max \lbrace D_0(G),1 \rbrace,10 \rbrace$$
   * where the $$D_0(1)=w_4$$ when the first rating is good.
   *
   * @param {Grade} g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
   * @return {number} Difficulty $$D \in [1,10]$$
   */
  init_difficulty(g2) {
    const w2 = this.param.w;
    const d2 = w2[4] - Math.exp((g2 - 1) * w2[5]) + 1;
    return roundTo(d2, 8);
  }
  /**
   * If fuzzing is disabled or ivl is less than 2.5, it returns the original interval.
   * @param {number} ivl - The interval to be fuzzed.
   * @param {number} elapsed_days t days since the last review
   * @return {number} - The fuzzed interval.
   **/
  apply_fuzz(ivl, elapsed_days) {
    if (!this.param.enable_fuzz || ivl < 2.5) return Math.round(ivl);
    const generator = alea(this._seed);
    const fuzz_factor = generator();
    const { min_ivl, max_ivl } = get_fuzz_range(
      ivl,
      elapsed_days,
      this.param.maximum_interval
    );
    return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
  }
  /**
   *   @see The formula used is : {@link FSRSAlgorithm.calculate_interval_modifier}
   *   @param {number} s - Stability (interval when R=90%)
   *   @param {number} elapsed_days t days since the last review
   */
  next_interval(s2, elapsed_days) {
    const newInterval = Math.min(
      Math.max(1, Math.round(s2 * this.intervalModifier)),
      this.param.maximum_interval
    );
    return this.apply_fuzz(newInterval, elapsed_days);
  }
  /**
   * @see https://github.com/open-spaced-repetition/fsrs4anki/issues/697
   */
  linear_damping(delta_d, old_d) {
    return roundTo(delta_d * (10 - old_d) / 9, 8);
  }
  /**
   * The formula used is :
   * $$\text{delta}_d = -w_6 \cdot (g - 3)$$
   * $$\text{next}_d = D + \text{linear damping}(\text{delta}_d , D)$$
   * $$D^\prime(D,R) = w_7 \cdot D_0(4) +(1 - w_7) \cdot \text{next}_d$$
   * @param {number} d Difficulty $$D \in [1,10]$$
   * @param {Grade} g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
   * @return {number} $$\text{next}_D$$
   */
  next_difficulty(d2, g2) {
    const delta_d = -this.param.w[6] * (g2 - 3);
    const next_d = d2 + this.linear_damping(delta_d, d2);
    return clamp(
      this.mean_reversion(this.init_difficulty(Rating.Easy), next_d),
      1,
      10
    );
  }
  /**
   * The formula used is :
   * $$w_7 \cdot \text{init} +(1 - w_7) \cdot \text{current}$$
   * @param {number} init $$w_2 : D_0(3) = w_2 + (R-2) \cdot w_3= w_2$$
   * @param {number} current $$D - w_6 \cdot (R - 2)$$
   * @return {number} difficulty
   */
  mean_reversion(init, current) {
    const w2 = this.param.w;
    return roundTo(w2[7] * init + (1 - w2[7]) * current, 8);
  }
  /**
   * The formula used is :
   * $$S^\prime_r(D,S,R,G) = S\cdot(e^{w_8}\cdot (11-D)\cdot S^{-w_9}\cdot(e^{w_{10}\cdot(1-R)}-1)\cdot w_{15}(\text{if} G=2) \cdot w_{16}(\text{if} G=4)+1)$$
   * @param {number} d Difficulty D \in [1,10]
   * @param {number} s Stability (interval when R=90%)
   * @param {number} r Retrievability (probability of recall)
   * @param {Grade} g Grade (Rating[0.again,1.hard,2.good,3.easy])
   * @return {number} S^\prime_r new stability after recall
   */
  next_recall_stability(d2, s2, r2, g2) {
    const w2 = this.param.w;
    const hard_penalty = Rating.Hard === g2 ? w2[15] : 1;
    const easy_bound = Rating.Easy === g2 ? w2[16] : 1;
    return roundTo(
      clamp(
        s2 * (1 + Math.exp(w2[8]) * (11 - d2) * Math.pow(s2, -w2[9]) * (Math.exp((1 - r2) * w2[10]) - 1) * hard_penalty * easy_bound),
        S_MIN,
        36500
      ),
      8
    );
  }
  /**
   * The formula used is :
   * $$S^\prime_f(D,S,R) = w_{11}\cdot D^{-w_{12}}\cdot ((S+1)^{w_{13}}-1) \cdot e^{w_{14}\cdot(1-R)}$$
   * enable_short_term = true : $$S^\prime_f \in \min \lbrace \max \lbrace S^\prime_f,0.01\rbrace, \frac{S}{e^{w_{17} \cdot w_{18}}} \rbrace$$
   * enable_short_term = false : $$S^\prime_f \in \min \lbrace \max \lbrace S^\prime_f,0.01\rbrace, S \rbrace$$
   * @param {number} d Difficulty D \in [1,10]
   * @param {number} s Stability (interval when R=90%)
   * @param {number} r Retrievability (probability of recall)
   * @return {number} S^\prime_f new stability after forgetting
   */
  next_forget_stability(d2, s2, r2) {
    const w2 = this.param.w;
    return roundTo(
      clamp(
        w2[11] * Math.pow(d2, -w2[12]) * (Math.pow(s2 + 1, w2[13]) - 1) * Math.exp((1 - r2) * w2[14]),
        S_MIN,
        36500
      ),
      8
    );
  }
  /**
   * The formula used is :
   * $$S^\prime_s(S,G) = S \cdot e^{w_{17} \cdot (G-3+w_{18})}$$
   * @param {number} s Stability (interval when R=90%)
   * @param {Grade} g Grade (Rating[0.again,1.hard,2.good,3.easy])
   */
  next_short_term_stability(s2, g2) {
    const w2 = this.param.w;
    const sinc = Math.pow(s2, -w2[19]) * Math.exp(w2[17] * (g2 - 3 + w2[18]));
    const maskedSinc = g2 >= Rating.Hard ? Math.max(sinc, 1) : sinc;
    return roundTo(clamp(s2 * maskedSinc, S_MIN, 36500), 8);
  }
  /**
   * Calculates the next state of memory based on the current state, time elapsed, and grade.
   *
   * @param memory_state - The current state of memory, which can be null.
   * @param t - The time elapsed since the last review.
   * @param {Rating} g Grade (Rating[0.Manual,1.Again,2.Hard,3.Good,4.Easy])
   * @param r - Optional retrievability value. If not provided, it will be calculated.
   * @returns The next state of memory with updated difficulty and stability.
   */
  next_state(memory_state, t3, g2, r2) {
    const { difficulty: d2, stability: s2 } = memory_state != null ? memory_state : {
      difficulty: 0,
      stability: 0
    };
    if (t3 < 0) {
      throw new FSRSValidationError(`Invalid delta_t "${t3}"`);
    }
    if (g2 < 0 || g2 > 4) {
      throw new FSRSValidationError(`Invalid grade "${g2}"`);
    }
    if (d2 === 0 && s2 === 0) {
      return {
        difficulty: clamp(this.init_difficulty(g2), 1, 10),
        stability: this.init_stability(g2)
      };
    }
    if (g2 === 0) {
      return {
        difficulty: d2,
        stability: s2
      };
    }
    if (d2 < 1 || s2 < S_MIN) {
      throw new FSRSValidationError(
        `Invalid memory state { difficulty: ${d2}, stability: ${s2} }`
      );
    }
    const w2 = this.param.w;
    r2 = typeof r2 === "number" ? r2 : this.forgetting_curve(t3, s2);
    let new_s;
    if (t3 === 0 && this.param.enable_short_term) {
      new_s = this.next_short_term_stability(s2, g2);
    } else if (g2 === 1) {
      const s_after_fail = this.next_forget_stability(d2, s2, r2);
      let [w_17, w_18] = [0, 0];
      if (this.param.enable_short_term) {
        w_17 = w2[17];
        w_18 = w2[18];
      }
      const next_s_min = s2 / Math.exp(w_17 * w_18);
      new_s = clamp(roundTo(next_s_min, 8), S_MIN, s_after_fail);
    } else {
      new_s = this.next_recall_stability(d2, s2, r2, g2);
    }
    const new_d = this.next_difficulty(d2, g2);
    return { difficulty: new_d, stability: new_s };
  }
};
var BasicScheduler = class extends AbstractScheduler {
  constructor(card, now2, algorithm, strategies) {
    super(card, now2, algorithm, strategies);
    __publicField(this, "learningStepsStrategy");
    let learningStepStrategy = BasicLearningStepsStrategy;
    if (this.strategies) {
      const custom_strategy = this.strategies.get(StrategyMode.LEARNING_STEPS);
      if (custom_strategy) {
        learningStepStrategy = custom_strategy;
      }
    }
    this.learningStepsStrategy = learningStepStrategy;
  }
  getLearningInfo(card, grade) {
    var _a2, _b, _c, _d;
    const parameters = this.algorithm.parameters;
    card.learning_steps = card.learning_steps || 0;
    const steps_strategy = this.learningStepsStrategy(
      parameters,
      card.state,
      card.learning_steps
    );
    const scheduled_minutes = Math.max(
      0,
      (_b = (_a2 = steps_strategy[grade]) == null ? void 0 : _a2.scheduled_minutes) != null ? _b : 0
    );
    const next_steps = Math.max(0, (_d = (_c = steps_strategy[grade]) == null ? void 0 : _c.next_step) != null ? _d : 0);
    return {
      scheduled_minutes,
      next_steps
    };
  }
  /**
   * @description This function applies the learning steps based on the current card's state and grade.
   */
  applyLearningSteps(nextCard, grade, to_state) {
    const { scheduled_minutes, next_steps } = this.getLearningInfo(
      this.current,
      grade
    );
    if (scheduled_minutes > 0 && scheduled_minutes < 1440) {
      nextCard.learning_steps = next_steps;
      nextCard.scheduled_days = 0;
      nextCard.state = to_state;
      nextCard.due = date_scheduler(
        this.review_time,
        Math.round(scheduled_minutes),
        false
        /** true:days false: minute */
      );
    } else {
      nextCard.state = State.Review;
      if (scheduled_minutes >= 1440) {
        nextCard.learning_steps = next_steps;
        nextCard.due = date_scheduler(
          this.review_time,
          Math.round(scheduled_minutes),
          false
          /** true:days false: minute */
        );
        nextCard.scheduled_days = Math.floor(scheduled_minutes / 1440);
      } else {
        nextCard.learning_steps = 0;
        const interval = this.algorithm.next_interval(
          nextCard.stability,
          this.elapsed_days
        );
        nextCard.scheduled_days = interval;
        nextCard.due = date_scheduler(this.review_time, interval, true);
      }
    }
  }
  newState(grade) {
    const exist = this.next.get(grade);
    if (exist) {
      return exist;
    }
    const next = this.next_ds(this.elapsed_days, grade);
    this.applyLearningSteps(next, grade, State.Learning);
    const item = {
      card: next,
      log: this.buildLog(grade)
    };
    this.next.set(grade, item);
    return item;
  }
  learningState(grade) {
    const exist = this.next.get(grade);
    if (exist) {
      return exist;
    }
    const next = this.next_ds(this.elapsed_days, grade);
    this.applyLearningSteps(
      next,
      grade,
      this.last.state
      /** Learning or Relearning */
    );
    const item = {
      card: next,
      log: this.buildLog(grade)
    };
    this.next.set(grade, item);
    return item;
  }
  reviewState(grade) {
    const exist = this.next.get(grade);
    if (exist) {
      return exist;
    }
    const interval = this.elapsed_days;
    const retrievability = this.algorithm.forgetting_curve(
      interval,
      this.current.stability
    );
    const next_again = this.next_ds(interval, Rating.Again, retrievability);
    const next_hard = this.next_ds(interval, Rating.Hard, retrievability);
    const next_good = this.next_ds(interval, Rating.Good, retrievability);
    const next_easy = this.next_ds(interval, Rating.Easy, retrievability);
    this.next_interval(next_hard, next_good, next_easy, interval);
    this.next_state(next_hard, next_good, next_easy);
    this.applyLearningSteps(next_again, Rating.Again, State.Relearning);
    next_again.lapses += 1;
    const item_again = {
      card: next_again,
      log: this.buildLog(Rating.Again)
    };
    const item_hard = {
      card: next_hard,
      log: super.buildLog(Rating.Hard)
    };
    const item_good = {
      card: next_good,
      log: super.buildLog(Rating.Good)
    };
    const item_easy = {
      card: next_easy,
      log: super.buildLog(Rating.Easy)
    };
    this.next.set(Rating.Again, item_again);
    this.next.set(Rating.Hard, item_hard);
    this.next.set(Rating.Good, item_good);
    this.next.set(Rating.Easy, item_easy);
    return this.next.get(grade);
  }
  /**
   * Review next_ds
   */
  next_ds(t3, g2, r2) {
    const next_state = this.algorithm.next_state(
      {
        difficulty: this.current.difficulty,
        stability: this.current.stability
      },
      t3,
      g2,
      r2
    );
    const card = TypeConvert.card(this.current);
    card.difficulty = next_state.difficulty;
    card.stability = next_state.stability;
    return card;
  }
  /**
   * Review next_interval
   */
  next_interval(next_hard, next_good, next_easy, interval) {
    let hard_interval, good_interval;
    hard_interval = this.algorithm.next_interval(next_hard.stability, interval);
    good_interval = this.algorithm.next_interval(next_good.stability, interval);
    hard_interval = Math.min(hard_interval, good_interval);
    good_interval = Math.max(good_interval, hard_interval + 1);
    const easy_interval = Math.max(
      this.algorithm.next_interval(next_easy.stability, interval),
      good_interval + 1
    );
    next_hard.scheduled_days = hard_interval;
    next_hard.due = date_scheduler(this.review_time, hard_interval, true);
    next_good.scheduled_days = good_interval;
    next_good.due = date_scheduler(this.review_time, good_interval, true);
    next_easy.scheduled_days = easy_interval;
    next_easy.due = date_scheduler(this.review_time, easy_interval, true);
  }
  /**
   * Review next_state
   */
  next_state(next_hard, next_good, next_easy) {
    next_hard.state = State.Review;
    next_hard.learning_steps = 0;
    next_good.state = State.Review;
    next_good.learning_steps = 0;
    next_easy.state = State.Review;
    next_easy.learning_steps = 0;
  }
};
var LongTermScheduler = class extends AbstractScheduler {
  newState(grade) {
    const exist = this.next.get(grade);
    if (exist) {
      return exist;
    }
    this.current.scheduled_days = 0;
    this.current.elapsed_days = 0;
    const first_interval = 0;
    const next_again = this.next_ds(first_interval, Rating.Again);
    const next_hard = this.next_ds(first_interval, Rating.Hard);
    const next_good = this.next_ds(first_interval, Rating.Good);
    const next_easy = this.next_ds(first_interval, Rating.Easy);
    this.next_interval(
      next_again,
      next_hard,
      next_good,
      next_easy,
      first_interval
    );
    this.next_state(next_again, next_hard, next_good, next_easy);
    this.update_next(next_again, next_hard, next_good, next_easy);
    return this.next.get(grade);
  }
  next_ds(t3, g2, r2) {
    const next_state = this.algorithm.next_state(
      {
        difficulty: this.current.difficulty,
        stability: this.current.stability
      },
      t3,
      g2,
      r2
    );
    const card = TypeConvert.card(this.current);
    card.difficulty = next_state.difficulty;
    card.stability = next_state.stability;
    return card;
  }
  /**
   * @see https://github.com/open-spaced-repetition/ts-fsrs/issues/98#issuecomment-2241923194
   */
  learningState(grade) {
    return this.reviewState(grade);
  }
  reviewState(grade) {
    const exist = this.next.get(grade);
    if (exist) {
      return exist;
    }
    const interval = this.elapsed_days;
    const retrievability = this.algorithm.forgetting_curve(
      interval,
      this.current.stability
    );
    const next_again = this.next_ds(interval, Rating.Again, retrievability);
    const next_hard = this.next_ds(interval, Rating.Hard, retrievability);
    const next_good = this.next_ds(interval, Rating.Good, retrievability);
    const next_easy = this.next_ds(interval, Rating.Easy, retrievability);
    this.next_interval(next_again, next_hard, next_good, next_easy, interval);
    this.next_state(next_again, next_hard, next_good, next_easy);
    next_again.lapses += 1;
    this.update_next(next_again, next_hard, next_good, next_easy);
    return this.next.get(grade);
  }
  /**
   * Review/New next_interval
   */
  next_interval(next_again, next_hard, next_good, next_easy, interval) {
    let again_interval, hard_interval, good_interval, easy_interval;
    again_interval = this.algorithm.next_interval(
      next_again.stability,
      interval
    );
    hard_interval = this.algorithm.next_interval(next_hard.stability, interval);
    good_interval = this.algorithm.next_interval(next_good.stability, interval);
    easy_interval = this.algorithm.next_interval(next_easy.stability, interval);
    again_interval = Math.min(again_interval, hard_interval);
    hard_interval = Math.max(hard_interval, again_interval + 1);
    good_interval = Math.max(good_interval, hard_interval + 1);
    easy_interval = Math.max(easy_interval, good_interval + 1);
    next_again.scheduled_days = again_interval;
    next_again.due = date_scheduler(this.review_time, again_interval, true);
    next_hard.scheduled_days = hard_interval;
    next_hard.due = date_scheduler(this.review_time, hard_interval, true);
    next_good.scheduled_days = good_interval;
    next_good.due = date_scheduler(this.review_time, good_interval, true);
    next_easy.scheduled_days = easy_interval;
    next_easy.due = date_scheduler(this.review_time, easy_interval, true);
  }
  /**
   * Review/New next_state
   */
  next_state(next_again, next_hard, next_good, next_easy) {
    next_again.state = State.Review;
    next_again.learning_steps = 0;
    next_hard.state = State.Review;
    next_hard.learning_steps = 0;
    next_good.state = State.Review;
    next_good.learning_steps = 0;
    next_easy.state = State.Review;
    next_easy.learning_steps = 0;
  }
  update_next(next_again, next_hard, next_good, next_easy) {
    const item_again = {
      card: next_again,
      log: this.buildLog(Rating.Again)
    };
    const item_hard = {
      card: next_hard,
      log: super.buildLog(Rating.Hard)
    };
    const item_good = {
      card: next_good,
      log: super.buildLog(Rating.Good)
    };
    const item_easy = {
      card: next_easy,
      log: super.buildLog(Rating.Easy)
    };
    this.next.set(Rating.Again, item_again);
    this.next.set(Rating.Hard, item_hard);
    this.next.set(Rating.Good, item_good);
    this.next.set(Rating.Easy, item_easy);
  }
};
var Reschedule = class {
  /**
   * Creates an instance of the `Reschedule` class.
   * @param fsrs - An instance of the FSRS class used for scheduling.
   */
  constructor(fsrs2) {
    __publicField(this, "fsrs");
    this.fsrs = fsrs2;
  }
  /**
   * Replays a review for a card and determines the next review date based on the given rating.
   * @param card - The card being reviewed.
   * @param reviewed - The date the card was reviewed.
   * @param rating - The grade given to the card during the review.
   * @returns A `RecordLogItem` containing the updated card and review log.
   */
  replay(card, reviewed, rating) {
    return this.fsrs.next(card, reviewed, rating);
  }
  /**
   * Processes a manual review for a card, allowing for custom state, stability, difficulty, and due date.
   * @param card - The card being reviewed.
   * @param state - The state of the card after the review.
   * @param reviewed - The date the card was reviewed.
   * @param elapsed_days - The number of days since the last review.
   * @param stability - (Optional) The stability of the card.
   * @param difficulty - (Optional) The difficulty of the card.
   * @param due - (Optional) The due date for the next review.
   * @returns A `RecordLogItem` containing the updated card and review log.
   * @throws Will throw an error if the state or due date is not provided when required.
   */
  handleManualRating(card, state, reviewed, elapsed_days, stability, difficulty, due) {
    if (typeof state === "undefined") {
      throw new FSRSValidationError(
        "reschedule: state is required for manual rating"
      );
    }
    let log;
    let next_card;
    if (state === State.New) {
      log = {
        rating: Rating.Manual,
        state,
        due: due != null ? due : reviewed,
        stability: card.stability,
        difficulty: card.difficulty,
        elapsed_days,
        last_elapsed_days: card.elapsed_days,
        scheduled_days: card.scheduled_days,
        learning_steps: card.learning_steps,
        review: reviewed
      };
      next_card = createEmptyCard(reviewed);
      next_card.last_review = reviewed;
    } else {
      if (typeof due === "undefined") {
        throw new FSRSValidationError(
          "reschedule: due is required for manual rating"
        );
      }
      const scheduled_days = date_diff(due, reviewed, "days");
      log = {
        rating: Rating.Manual,
        state: card.state,
        due: card.last_review || card.due,
        stability: card.stability,
        difficulty: card.difficulty,
        elapsed_days,
        last_elapsed_days: card.elapsed_days,
        scheduled_days: card.scheduled_days,
        learning_steps: card.learning_steps,
        review: reviewed
      };
      next_card = {
        ...card,
        state,
        due,
        last_review: reviewed,
        stability: stability || card.stability,
        difficulty: difficulty || card.difficulty,
        elapsed_days,
        scheduled_days,
        reps: card.reps + 1
      };
    }
    return { card: next_card, log };
  }
  /**
   * Reschedules a card based on its review history.
   *
   * @param current_card - The card to be rescheduled.
   * @param reviews - An array of review history objects.
   * @returns An array of record log items representing the rescheduling process.
   */
  reschedule(current_card, reviews) {
    const collections = [];
    let cur_card = createEmptyCard(current_card.due);
    for (const review of reviews) {
      let item;
      review.review = TypeConvert.time(review.review);
      if (review.rating === Rating.Manual) {
        let interval = 0;
        if (cur_card.state !== State.New && cur_card.last_review) {
          interval = date_diff(review.review, cur_card.last_review, "days");
        }
        item = this.handleManualRating(
          cur_card,
          review.state,
          review.review,
          interval,
          review.stability,
          review.difficulty,
          review.due ? TypeConvert.time(review.due) : void 0
        );
      } else {
        item = this.replay(cur_card, review.review, review.rating);
      }
      collections.push(item);
      cur_card = item.card;
    }
    return collections;
  }
  calculateManualRecord(current_card, now2, record_log_item, update_memory) {
    if (!record_log_item) {
      return null;
    }
    const { card: reschedule_card, log } = record_log_item;
    const cur_card = TypeConvert.card(current_card);
    if (cur_card.due.getTime() === reschedule_card.due.getTime()) {
      return null;
    }
    cur_card.scheduled_days = date_diff(
      reschedule_card.due,
      cur_card.due,
      "days"
    );
    return this.handleManualRating(
      cur_card,
      reschedule_card.state,
      TypeConvert.time(now2),
      log.elapsed_days,
      update_memory ? reschedule_card.stability : void 0,
      update_memory ? reschedule_card.difficulty : void 0,
      reschedule_card.due
    );
  }
};
function applyAfterHandler(value, afterHandler) {
  return typeof afterHandler === "function" ? afterHandler(value) : value;
}
var FSRS = class extends FSRSAlgorithm {
  constructor(param) {
    super(param);
    __publicField(this, "strategyHandler", /* @__PURE__ */ new Map());
    __publicField(this, "Scheduler");
    const { enable_short_term } = this.parameters;
    this.Scheduler = enable_short_term ? BasicScheduler : LongTermScheduler;
  }
  params_handler_proxy() {
    const _this = this;
    return {
      set: function(target, prop, value) {
        if (prop === "request_retention" && Number.isFinite(value)) {
          _this.intervalModifier = _this.calculate_interval_modifier(
            Number(value)
          );
        } else if (prop === "enable_short_term") {
          _this.Scheduler = value === true ? BasicScheduler : LongTermScheduler;
        } else if (prop === "w") {
          value = migrateParameters(
            value,
            target.relearning_steps.length,
            target.enable_short_term
          );
          _this.forgetting_curve = forgetting_curve.bind(this, value);
          _this.intervalModifier = _this.calculate_interval_modifier(
            Number(target.request_retention)
          );
        }
        Reflect.set(target, prop, value);
        return true;
      }
    };
  }
  useStrategy(mode, handler) {
    this.strategyHandler.set(mode, handler);
    return this;
  }
  clearStrategy(mode) {
    if (mode) {
      this.strategyHandler.delete(mode);
    } else {
      this.strategyHandler.clear();
    }
    return this;
  }
  getScheduler(card, now2) {
    const schedulerStrategy = this.strategyHandler.get(
      StrategyMode.SCHEDULER
    );
    const Scheduler = schedulerStrategy || this.Scheduler;
    const instance = new Scheduler(card, now2, this, this.strategyHandler);
    return instance;
  }
  /**
   * Display the collection of cards and logs for the four scenarios after scheduling the card at the current time.
   * @param card Card to be processed
   * @param now Current time or scheduled time
   * @param afterHandler Convert the result to another type. (Optional)
   * @example
   * ```typescript
   * const card: Card = createEmptyCard(new Date());
   * const f = fsrs();
   * const recordLog = f.repeat(card, new Date());
   * ```
   * @example
   * ```typescript
   * interface RevLogUnchecked
   *   extends Omit<ReviewLog, "due" | "review" | "state" | "rating"> {
   *   cid: string;
   *   due: Date | number;
   *   state: StateType;
   *   review: Date | number;
   *   rating: RatingType;
   * }
   *
   * interface RepeatRecordLog {
   *   card: CardUnChecked; //see method: createEmptyCard
   *   log: RevLogUnchecked;
   * }
   *
   * function repeatAfterHandler(recordLog: RecordLog) {
   *     const record: { [key in Grade]: RepeatRecordLog } = {} as {
   *       [key in Grade]: RepeatRecordLog;
   *     };
   *     for (const grade of Grades) {
   *       record[grade] = {
   *         card: {
   *           ...(recordLog[grade].card as Card & { cid: string }),
   *           due: recordLog[grade].card.due.getTime(),
   *           state: State[recordLog[grade].card.state] as StateType,
   *           last_review: recordLog[grade].card.last_review
   *             ? recordLog[grade].card.last_review!.getTime()
   *             : null,
   *         },
   *         log: {
   *           ...recordLog[grade].log,
   *           cid: (recordLog[grade].card as Card & { cid: string }).cid,
   *           due: recordLog[grade].log.due.getTime(),
   *           review: recordLog[grade].log.review.getTime(),
   *           state: State[recordLog[grade].log.state] as StateType,
   *           rating: Rating[recordLog[grade].log.rating] as RatingType,
   *         },
   *       };
   *     }
   *     return record;
   * }
   * const card: Card = createEmptyCard(new Date(), cardAfterHandler); //see method:  createEmptyCard
   * const f = fsrs();
   * const recordLog = f.repeat(card, new Date(), repeatAfterHandler);
   * ```
   */
  repeat(card, now2, afterHandler) {
    const instance = this.getScheduler(card, now2);
    const recordLog = instance.preview();
    return applyAfterHandler(recordLog, afterHandler);
  }
  /**
   * Display the collection of cards and logs for the card scheduled at the current time, after applying a specific grade rating.
   * @param card Card to be processed
   * @param now Current time or scheduled time
   * @param grade Rating of the review (Again, Hard, Good, Easy)
   * @param afterHandler Convert the result to another type. (Optional)
   * @example
   * ```typescript
   * const card: Card = createEmptyCard(new Date());
   * const f = fsrs();
   * const recordLogItem = f.next(card, new Date(), Rating.Again);
   * ```
   * @example
   * ```typescript
   * interface RevLogUnchecked
   *   extends Omit<ReviewLog, "due" | "review" | "state" | "rating"> {
   *   cid: string;
   *   due: Date | number;
   *   state: StateType;
   *   review: Date | number;
   *   rating: RatingType;
   * }
   *
   * interface NextRecordLog {
   *   card: CardUnChecked; //see method: createEmptyCard
   *   log: RevLogUnchecked;
   * }
   *
  function nextAfterHandler(recordLogItem: RecordLogItem) {
    const recordItem = {
      card: {
        ...(recordLogItem.card as Card & { cid: string }),
        due: recordLogItem.card.due.getTime(),
        state: State[recordLogItem.card.state] as StateType,
        last_review: recordLogItem.card.last_review
          ? recordLogItem.card.last_review!.getTime()
          : null,
      },
      log: {
        ...recordLogItem.log,
        cid: (recordLogItem.card as Card & { cid: string }).cid,
        due: recordLogItem.log.due.getTime(),
        review: recordLogItem.log.review.getTime(),
        state: State[recordLogItem.log.state] as StateType,
        rating: Rating[recordLogItem.log.rating] as RatingType,
      },
    };
    return recordItem
  }
   * const card: Card = createEmptyCard(new Date(), cardAfterHandler); //see method:  createEmptyCard
   * const f = fsrs();
   * const recordLogItem = f.repeat(card, new Date(), Rating.Again, nextAfterHandler);
   * ```
   */
  next(card, now2, grade, afterHandler) {
    const instance = this.getScheduler(card, now2);
    const g2 = TypeConvert.rating(grade);
    if (g2 === Rating.Manual) {
      throw new FSRSValidationError("Cannot review a manual rating");
    }
    const recordLogItem = instance.review(g2);
    return applyAfterHandler(recordLogItem, afterHandler);
  }
  /**
   * Get the retrievability of the card
   * @param card  Card to be processed
   * @param now  Current time or scheduled time
   * @param format  default:true , Convert the result to another type. (Optional)
   * @returns  The retrievability of the card,if format is true, the result is a string, otherwise it is a number
   */
  get_retrievability(card, now2, format = true) {
    const processedCard = TypeConvert.card(card);
    now2 = now2 ? TypeConvert.time(now2) : /* @__PURE__ */ new Date();
    const t3 = processedCard.state !== State.New ? Math.max(date_diff(now2, processedCard.last_review, "days"), 0) : 0;
    const r2 = processedCard.state !== State.New ? this.forgetting_curve(t3, +processedCard.stability.toFixed(8)) : 0;
    return format ? `${(r2 * 100).toFixed(2)}%` : r2;
  }
  /**
   *
   * @param card Card to be processed
   * @param log last review log
   * @param afterHandler Convert the result to another type. (Optional)
   * @example
   * ```typescript
   * const now = new Date();
   * const f = fsrs();
   * const emptyCardFormAfterHandler = createEmptyCard(now);
   * const repeatFormAfterHandler = f.repeat(emptyCardFormAfterHandler, now);
   * const { card, log } = repeatFormAfterHandler[Rating.Hard];
   * const rollbackFromAfterHandler = f.rollback(card, log);
   * ```
   *
   * @example
   * ```typescript
   * const now = new Date();
   * const f = fsrs();
   * const emptyCardFormAfterHandler = createEmptyCard(now, cardAfterHandler);  //see method: createEmptyCard
   * const repeatFormAfterHandler = f.repeat(emptyCardFormAfterHandler, now, repeatAfterHandler); //see method: fsrs.repeat()
   * const { card, log } = repeatFormAfterHandler[Rating.Hard];
   * const rollbackFromAfterHandler = f.rollback(card, log, cardAfterHandler);
   * ```
   */
  rollback(card, log, afterHandler) {
    const processedCard = TypeConvert.card(card);
    const processedLog = TypeConvert.review_log(log);
    if (processedLog.rating === Rating.Manual) {
      throw new FSRSValidationError("Cannot rollback a manual rating");
    }
    let last_due;
    let last_review;
    let last_lapses;
    switch (processedLog.state) {
      case State.New:
        last_due = processedLog.due;
        last_review = void 0;
        last_lapses = 0;
        break;
      case State.Learning:
      case State.Relearning:
      case State.Review:
        last_due = processedLog.review;
        last_review = processedLog.due;
        last_lapses = processedCard.lapses - (processedLog.rating === Rating.Again && processedLog.state === State.Review ? 1 : 0);
        break;
    }
    const prevCard = {
      ...processedCard,
      due: last_due,
      stability: processedLog.stability,
      difficulty: processedLog.difficulty,
      elapsed_days: processedLog.last_elapsed_days,
      scheduled_days: processedLog.scheduled_days,
      reps: Math.max(0, processedCard.reps - 1),
      lapses: Math.max(0, last_lapses),
      learning_steps: processedLog.learning_steps,
      state: processedLog.state,
      last_review
    };
    return applyAfterHandler(prevCard, afterHandler);
  }
  /**
   *
   * @param card Card to be processed
   * @param now Current time or scheduled time
   * @param reset_count Should the review count information(reps,lapses) be reset. (Optional)
   * @param afterHandler Convert the result to another type. (Optional)
   * @example
   * ```typescript
   * const now = new Date();
   * const f = fsrs();
   * const emptyCard = createEmptyCard(now);
   * const scheduling_cards = f.repeat(emptyCard, now);
   * const { card, log } = scheduling_cards[Rating.Hard];
   * const forgetCard = f.forget(card, new Date(), true);
   * ```
   *
   * @example
   * ```typescript
   * interface RepeatRecordLog {
   *   card: CardUnChecked; //see method: createEmptyCard
   *   log: RevLogUnchecked; //see method: fsrs.repeat()
   * }
   *
   * function forgetAfterHandler(recordLogItem: RecordLogItem): RepeatRecordLog {
   *     return {
   *       card: {
   *         ...(recordLogItem.card as Card & { cid: string }),
   *         due: recordLogItem.card.due.getTime(),
   *         state: State[recordLogItem.card.state] as StateType,
   *         last_review: recordLogItem.card.last_review
   *           ? recordLogItem.card.last_review!.getTime()
   *           : null,
   *       },
   *       log: {
   *         ...recordLogItem.log,
   *         cid: (recordLogItem.card as Card & { cid: string }).cid,
   *         due: recordLogItem.log.due.getTime(),
   *         review: recordLogItem.log.review.getTime(),
   *         state: State[recordLogItem.log.state] as StateType,
   *         rating: Rating[recordLogItem.log.rating] as RatingType,
   *       },
   *     };
   * }
   * const now = new Date();
   * const f = fsrs();
   * const emptyCardFormAfterHandler = createEmptyCard(now, cardAfterHandler); //see method:  createEmptyCard
   * const repeatFormAfterHandler = f.repeat(emptyCardFormAfterHandler, now, repeatAfterHandler); //see method: fsrs.repeat()
   * const { card } = repeatFormAfterHandler[Rating.Hard];
   * const forgetFromAfterHandler = f.forget(card, date_scheduler(now, 1, true), false, forgetAfterHandler);
   * ```
   */
  forget(card, now2, reset_count = false, afterHandler) {
    const processedCard = TypeConvert.card(card);
    now2 = TypeConvert.time(now2);
    const scheduled_days = processedCard.state === State.New ? 0 : date_diff(now2, processedCard.due, "days");
    const forget_log = {
      rating: Rating.Manual,
      state: processedCard.state,
      due: processedCard.due,
      stability: processedCard.stability,
      difficulty: processedCard.difficulty,
      elapsed_days: 0,
      last_elapsed_days: processedCard.elapsed_days,
      scheduled_days,
      learning_steps: processedCard.learning_steps,
      review: now2
    };
    const forget_card = {
      ...processedCard,
      due: now2,
      stability: 0,
      difficulty: 0,
      elapsed_days: 0,
      scheduled_days: 0,
      reps: reset_count ? 0 : processedCard.reps,
      lapses: reset_count ? 0 : processedCard.lapses,
      learning_steps: 0,
      state: State.New,
      last_review: processedCard.last_review
    };
    const recordLogItem = { card: forget_card, log: forget_log };
    return applyAfterHandler(recordLogItem, afterHandler);
  }
  /**
   * Reschedules the current card and returns the rescheduled collections and reschedule item.
   *
   * @template T - The type of the record log item.
   * @param {CardInput | Card} current_card - The current card to be rescheduled.
   * @param {Array<FSRSHistory>} reviews - The array of FSRSHistory objects representing the reviews.
   * @param {Partial<RescheduleOptions<T>>} options - The optional reschedule options.
   * @returns {IReschedule<T>} - The rescheduled collections and reschedule item.
   *
   * @example
   * ```typescript
   * const f = fsrs()
   * const grades: Grade[] = [Rating.Good, Rating.Good, Rating.Good, Rating.Good]
   * const reviews_at = [
   *   new Date(2024, 8, 13),
   *   new Date(2024, 8, 13),
   *   new Date(2024, 8, 17),
   *   new Date(2024, 8, 28),
   * ]
   *
   * const reviews: FSRSHistory[] = []
   * for (let i = 0; i < grades.length; i++) {
   *   reviews.push({
   *     rating: grades[i],
   *     review: reviews_at[i],
   *   })
   * }
   *
   * const results_short = scheduler.reschedule(
   *   createEmptyCard(),
   *   reviews,
   *   {
   *     skipManual: false,
   *   }
   * )
   * console.log(results_short)
   * ```
   */
  reschedule(current_card, reviews = [], options = {}) {
    const {
      recordLogHandler,
      reviewsOrderBy,
      skipManual = true,
      now: now2 = /* @__PURE__ */ new Date(),
      update_memory_state: updateMemoryState = false
    } = options;
    if (reviewsOrderBy && typeof reviewsOrderBy === "function") {
      reviews.sort(reviewsOrderBy);
    }
    if (skipManual) {
      reviews = reviews.filter((review) => review.rating !== Rating.Manual);
    }
    const rescheduleSvc = new Reschedule(this);
    const collections = rescheduleSvc.reschedule(
      options.first_card || createEmptyCard(),
      reviews
    );
    const len = collections.length;
    const cur_card = TypeConvert.card(current_card);
    const manual_item = rescheduleSvc.calculateManualRecord(
      cur_card,
      now2,
      len ? collections[len - 1] : void 0,
      updateMemoryState
    );
    return {
      collections: typeof recordLogHandler === "function" ? collections.map(recordLogHandler) : collections,
      reschedule_item: manual_item ? applyAfterHandler(manual_item, recordLogHandler) : null
    };
  }
};
var fsrs = (params) => {
  return new FSRS(params || {});
};

// src/scheduling/algorithms/fsrs/fsrs-helpers.ts
var FSRS_COMMENT_PREFIX = "fsrs";
var LEGACY_MIN_EASE = 130;
var LEGACY_MAX_EASE = 370;
function buildFsrsParameters(settings) {
  return {
    ["request_retention"]: settings.fsrsDesiredRetention,
    ["maximum_interval"]: settings.maximumInterval,
    ["enable_short_term"]: true
  };
}
function reviewResponseToFsrsGrade(response) {
  switch (response) {
    case 3 /* Again */:
      return Rating.Again;
    case 2 /* Hard */:
      return Rating.Hard;
    case 1 /* Good */:
      return Rating.Good;
    case 0 /* Easy */:
      return Rating.Easy;
    default:
      throw new Error(`Unsupported FSRS response: ${response}`);
  }
}
function easeToDifficulty(ease) {
  if (ease === null || ease === void 0) {
    return 5.5;
  }
  const clampedEase = clamp2(ease, LEGACY_MIN_EASE, LEGACY_MAX_EASE);
  const normalized = (clampedEase - LEGACY_MIN_EASE) / (LEGACY_MAX_EASE - LEGACY_MIN_EASE);
  return clamp2(10 - normalized * 9, 1, 10);
}
function difficultyToEase(difficulty) {
  const clampedDifficulty = clamp2(difficulty, 1, 10);
  const normalized = (10 - clampedDifficulty) / 9;
  return Math.round(LEGACY_MIN_EASE + normalized * (LEGACY_MAX_EASE - LEGACY_MIN_EASE));
}
function sm2ScheduleToFsrsCard(schedule, now2) {
  var _a2;
  const interval = Math.max(1, Math.round((_a2 = schedule == null ? void 0 : schedule.interval) != null ? _a2 : 1));
  const due = (schedule == null ? void 0 : schedule.dueDate) ? schedule.dueDate.clone() : now2.clone();
  const lastReview = due.clone().subtract(interval, "d");
  return {
    due: due.toDate(),
    stability: Math.max(0.1, interval),
    difficulty: easeToDifficulty(schedule == null ? void 0 : schedule.latestEase),
    ["elapsed_days"]: Math.max(0, now2.diff(lastReview, "days")),
    ["scheduled_days"]: interval,
    ["learning_steps"]: 0,
    reps: Math.max(1, Math.round(Math.log2(interval + 1))),
    lapses: 0,
    state: State.Review,
    ["last_review"]: lastReview.toDate()
  };
}
function formatFsrsTimestamp(date) {
  return date ? date.toDate().toISOString() : "-";
}
function parseFsrsTimestamp(input) {
  return input === "-" ? null : (0, import_moment5.default)(input);
}
function clamp2(value, min, max) {
  return Math.min(max, Math.max(min, value));
}

// src/scheduling/algorithms/fsrs/rep-item-schedule-info-fsrs.ts
var import_moment6 = __toESM(require_moment());
var RepItemScheduleInfoFsrs = class _RepItemScheduleInfoFsrs extends RepItemScheduleInfo {
  constructor(dueDate, interval, difficulty, stability, state, reps, lapses, learningSteps, lastReview) {
    super(
      "FSRS" /* FSRS */,
      dueDate,
      interval,
      difficultyToEase(difficulty),
      dueDate && globalDateProvider.now ? globalDateProvider.now.valueOf() - dueDate.valueOf() : 0
    );
    this.difficulty = difficulty;
    this.stability = stability;
    this.state = state;
    this.reps = reps;
    this.lapses = lapses;
    this.learningSteps = learningSteps;
    this.lastReview = lastReview;
  }
  /**
   * Creates a RepItemScheduleInfoFsrs object from a Card or CardInput object.
   *
   *  NOTE: The fsrs library uses cards as the basic unit of scheduling, so we need to convert the Card or CardInput object to a RepItemScheduleInfoFsrs object.
   *
   * @param {Card | CardInput} card - The Card or CardInput object.
   * @returns {RepItemScheduleInfoFsrs} - The RepItemScheduleInfoFsrs object.
   */
  static fromFsrsCard(card) {
    return new _RepItemScheduleInfoFsrs(
      (0, import_moment6.default)(card.due),
      card.scheduled_days,
      card.difficulty,
      card.stability,
      card.state,
      card.reps,
      card.lapses,
      card.learning_steps,
      card.last_review ? (0, import_moment6.default)(card.last_review) : null
    );
  }
  /**
   * Converts the RepItemScheduleInfoFsrs object to a CardInput object for use with the fsrs library.
   *
   * @param {Moment} [now] - The current date and time. Defaults to the current date and time.
   * @returns {CardInput} - The CardInput object.
   */
  toFsrsCardInput(now2 = globalDateProvider.now) {
    const lastReview = this.lastReview ? this.lastReview.clone() : now2.clone();
    return {
      due: this.dueDate.toDate(),
      stability: this.stability,
      difficulty: this.difficulty,
      ["elapsed_days"]: Math.max(0, now2.diff(lastReview, "days")),
      ["scheduled_days"]: this.interval,
      ["learning_steps"]: this.learningSteps,
      reps: this.reps,
      lapses: this.lapses,
      state: this.state,
      ["last_review"]: this.lastReview ? this.lastReview.toDate() : null
    };
  }
  /**
   * Checks if the repetition item is short term.
   *
   * @returns {boolean} - True if the repetition item is short term, false otherwise.
   */
  isShortTerm() {
    return this.interval < 1;
  }
  /**
   * Formats the scheduling information for the repetition item as a string for HTML comments.
   *
   * @returns {string} - The formatted scheduling information.
   */
  formatScheduleAsSRHtmlComment() {
    return `!${FSRS_COMMENT_PREFIX},${formatFsrsTimestamp(this.dueDate)},${this.interval},${this.stability},${this.difficulty},${this.state},${this.reps},${this.lapses},${this.learningSteps},${formatFsrsTimestamp(this.lastReview)}`;
  }
  /**
   * Formats the scheduling information for the repetition item as a JSON string.
   *
   * @returns {string} - The formatted scheduling information.
   */
  serializeSchedule() {
    const serializedData = {
      dueDate: formatFsrsTimestamp(this.dueDate),
      interval: this.interval,
      stability: this.stability,
      difficulty: this.difficulty,
      state: this.state,
      reps: this.reps,
      lapses: this.lapses,
      learningSteps: this.learningSteps,
      lastReview: formatFsrsTimestamp(this.lastReview)
    };
    return {
      algorithm: "FSRS" /* FSRS */,
      scheduleData: serializedData
    };
  }
};

// src/utils/comment-parser.ts
var CommentParser = class {
  static parseMultiScheduleComment(comment) {
    const segments = comment.split("!").map((segment) => segment.trim()).filter((segment) => segment.length > 0).map((segment) => this.parseScheduleSegment(segment)).filter((info) => info !== null);
    return segments;
  }
  static parseScheduleSegment(segment) {
    if (segment.startsWith(FSRS_COMMENT_PREFIX + ",")) {
      const fields = segment.split(",");
      const [
        _algorithm,
        dueDateStr2,
        intervalStr2,
        stabilityStr,
        difficultyStr,
        stateStr,
        repsStr,
        lapsesStr,
        learningStepsStr,
        lastReviewStr
      ] = fields;
      const parsedDueDate = parseFsrsTimestamp(dueDateStr2);
      if (!parsedDueDate) {
        return null;
      }
      return new RepItemScheduleInfoFsrs(
        parsedDueDate,
        parseFloat(intervalStr2),
        parseFloat(difficultyStr),
        parseFloat(stabilityStr),
        parseInt(stateStr),
        parseInt(repsStr),
        parseInt(lapsesStr),
        parseInt(learningStepsStr),
        parseFsrsTimestamp(lastReviewStr)
      );
    }
    const [dueDateStr, intervalStr, easeStr] = segment.split(",");
    return this.parseSM2Schedule(dueDateStr, parseInt(intervalStr), parseInt(easeStr));
  }
  static parseSM2Schedule(dueDateStr, interval, ease) {
    const dueDate = DateUtil.dateStrToMoment(dueDateStr);
    if (dueDate === null || formatDate(dueDate.unix(), PREFERRED_DATE_FORMAT) === RepItemScheduleInfoOsr.dummyDueDateForNewCard) {
      return null;
    }
    const delayBeforeReviewTicks = dueDate.valueOf() - globalDateProvider.today.valueOf();
    return new RepItemScheduleInfoOsr(dueDate, interval, ease, delayBeforeReviewTicks);
  }
};

// src/data/data-store/notes-data-store/notes-data-store.ts
var NotesDataStore = class {
  constructor(settings, scheduleDeleter) {
    this.storageType = "NOTES" /* NOTES */;
    this.settings = settings;
    this.fileModifier = scheduleDeleter;
    this.isStructureInitialized = Promise.resolve(true);
  }
  /**
   * Creates scheduling information from a question text and its storage info.
   *
   * @param originalQuestionText
   * @param _
   * @returns
   */
  createSchedule(originalQuestionText, _2) {
    var _a2, _b;
    const schedulingComment = (_a2 = originalQuestionText.match(/<!--SR:(.+?)-->/m)) == null ? void 0 : _a2[1];
    if (schedulingComment) {
      return (_b = CommentParser.parseMultiScheduleComment(schedulingComment)) != null ? _b : [];
    }
    const sm2MultiScheduling = [...originalQuestionText.matchAll(MULTI_SCHEDULING_EXTRACTOR)];
    if (sm2MultiScheduling.length > 0) {
      return sm2MultiScheduling.map(
        (match2) => CommentParser.parseSM2Schedule(
          match2[1],
          parseInt(match2[2]),
          parseInt(match2[3])
        )
      ).filter((info) => info !== null);
    }
    const result = [];
    const scheduling = [...originalQuestionText.matchAll(SM2_SCHEDULE_INFO_EXTRACTOR)];
    for (const match2 of scheduling) {
      const dueDateStr = match2[1];
      const interval = parseInt(match2[2]);
      const ease = parseInt(match2[3]);
      const parsedSchedule = CommentParser.parseSM2Schedule(dueDateStr, interval, ease);
      if (parsedSchedule) {
        result.push(parsedSchedule);
      }
    }
    return result;
  }
  /**
   * Removes scheduling information from a question text.
   *
   * @param questionText
   * @returns
   */
  removeScheduleInfo(questionText) {
    return questionText.replace(/<!--SR:.+-->/gm, "");
  }
  /**
   * Writes scheduling information to the data store.
   *
   * @param question
   * @returns
   */
  async writeSchedule(question) {
    await this.write(question);
  }
  /**
   * Writes a question to the data store.
   *
   * @param question
   * @returns
   */
  async write(question) {
    const fileText = await question.note.file.read();
    const newText = question.updateQuestionWithinNoteText(fileText, this.settings);
    await question.note.file.write(newText);
    question.hasChanged = false;
  }
  /**
   * Deletes a question from the data store.
   *
   * @param question
   * @returns
   */
  async delete(question) {
    const fileText = await question.note.file.read();
    const originalText = question.questionText.original;
    const newText = MultiLineTextFinder.findAndReplace(fileText, originalText, "");
    if (newText) {
      await question.note.file.write(newText);
    }
  }
};

// src/data/data-structures/card/questions/question-postponement-list.ts
var QuestionPostponementList = class {
  constructor(pluginDataManager, settings, list) {
    this.pluginDataManager = pluginDataManager;
    this.settings = settings;
    this.list = list;
  }
  /**
   * Clears the list of postponed questions if the date has changed since the last time the list was cleared. This ensures that questions are only postponed for one day.
   *
   * @param {PluginData} data - The plugin data containing the bury date and list.
   * @returns {Promise<void>} - A promise that resolves when the list is cleared if it's a new day.
   */
  async clearIfNewDay(data) {
    const now2 = window.moment(Date.now());
    const todayDate = now2.format("YYYY-MM-DD");
    const isNewDay = todayDate !== data.buryDate;
    if (isNewDay) {
      data.buryDate = todayDate;
      this.clear();
      await this.write();
    }
  }
  /**
   * Clears the list of postponed questions.
   */
  clear() {
    this.list.splice(0);
  }
  /**
   * Adds a question to the list of postponed questions.
   *
   * @param {Question} question - The question to add.
   */
  add(question) {
    if (!this.includes(question)) this.list.push(question.questionText.textHash);
  }
  /**
   * Checks if a question is in the list of postponed questions.
   *
   * @param {Question} question - The question to check.
   * @returns {boolean} - True if the question is in the list, false otherwise.
   */
  includes(question) {
    return this.list.includes(question.questionText.textHash);
  }
  /**
   * Writes the list of postponed questions to the plugin data.
   *
   * @returns {Promise<void>} - A promise that resolves when the list is written.
   */
  async write() {
    if (this.pluginDataManager === null) return;
    await this.pluginDataManager.savePluginData();
  }
};

// src/data/data-structures/file/note-file.ts
var import_moment7 = __toESM(require_moment());
var SRNoteTFile = class extends SRTFile {
  constructor(vault, metadataCache, fileManager, file) {
    super(vault, metadataCache, fileManager, file);
  }
  /**
   * Gets the scheduling information for the note.
   *
   * @returns {Promise<RepItemScheduleInfo>} - A promise that resolves with the scheduling information for the note.
   */
  async getNoteSchedule() {
    const frontmatter = await this.getFrontmatter();
    const srInterval = frontmatter.get("sr-interval");
    const srEase = frontmatter.get("sr-ease");
    const srDue = frontmatter.get("sr-due");
    if (!(srInterval && srEase && srDue)) return null;
    const dueDate = (0, import_moment7.default)(srDue, ALLOWED_DATE_FORMATS);
    const interval = parseFloat(srInterval);
    const ease = parseFloat(srEase);
    return new RepItemScheduleInfoOsr(dueDate, interval, ease);
  }
  /**
   * Sets the scheduling information for the note.
   *
   * @param {RepItemScheduleInfo} repItemScheduleInfo - The scheduling information for the note.
   * @returns {Promise<void>} - A promise that resolves when the scheduling information is set.
   */
  async setNoteSchedule(repItemScheduleInfo) {
    const scheduleInfo = repItemScheduleInfo;
    const dueString = formatDate(scheduleInfo.dueDateAsUnix, PREFERRED_DATE_FORMAT);
    const interval = scheduleInfo.interval;
    const ease = scheduleInfo.latestEase;
    await this.fileManager.processFrontMatter(this.tfile, (frontmatter) => {
      frontmatter["sr-due"] = dueString;
      frontmatter["sr-interval"] = interval;
      frontmatter["sr-ease"] = ease;
    });
  }
  /**
   * Gets the note ID from the frontmatter.
   *
   * @returns {Promise<string | null>} - A promise that resolves with the note ID from the frontmatter, or null if not found.
   */
  async getNoteId() {
    var _a2;
    const frontmatter = await this.getFrontmatter();
    return (_a2 = frontmatter == null ? void 0 : frontmatter.get("sr-id")) != null ? _a2 : null;
  }
  /**
   * Gets or creates the note ID from the frontmatter.
   *
   * @returns {Promise<string>} - A promise that resolves with the note ID from the frontmatter, or a new one if not found.
   */
  async getOrCreateNoteId() {
    const existing = await this.getNoteId();
    if (existing) return existing;
    const id2 = crypto.randomUUID();
    await this.fileManager.processFrontMatter(this.tfile, (frontmatter) => {
      frontmatter["sr-id"] = id2;
    });
    return id2;
  }
  /**
   * Gets the question context for a given line number.
   *
   * @param {number} cardLine - The line number of the card.
   * @returns {string[]} - An array of strings representing the question context.
   */
  getQuestionContext(cardLine) {
    const fileCachedData = this.metadataCache.getFileCache(this.file) || {};
    const headings = fileCachedData.headings || [];
    const stack = [];
    for (const heading of headings) {
      if (heading.position.start.line > cardLine) {
        break;
      }
      while (stack.length > 0 && stack[stack.length - 1].level >= heading.level) {
        stack.pop();
      }
      stack.push(heading);
    }
    const result = [];
    for (const headingObj of stack) {
      headingObj.heading = headingObj.heading.replace(/\[\^\d+\]/gm, "").trim();
      result.push(headingObj.heading);
    }
    return result;
  }
};

// src/scheduling/algorithms/osr/srs-algorithm-osr.ts
var import_moment8 = __toESM(require_moment());

// src/note/note-ease-list.ts
var NoteEaseList = class {
  constructor(settings) {
    this.dict = {};
    this.settings = settings;
  }
  get baseEase() {
    return this.settings.baseEase;
  }
  hasEaseForPath(path2) {
    return Object.prototype.hasOwnProperty.call(this.dict, path2);
  }
  getEaseByPath(path2) {
    let ease = null;
    if (this.hasEaseForPath(path2)) {
      ease = Math.round(this.dict[path2]);
    }
    return ease;
  }
  setEaseForPath(path2, ease) {
    this.dict[path2] = ease;
  }
};

// src/scheduling/algorithms/osr/srs-algorithm-osr.ts
var SRAlgorithmOsr = class _SRAlgorithmOsr {
  constructor(settings) {
    this.algorithmType = "SM-2-OSR" /* SM_2_OSR */;
    this.settings = settings;
    this.noteEaseList = new NoteEaseList(settings);
  }
  static get initialInterval() {
    return 1;
  }
  /**
   * Calculates the new schedule for a note.
   *
   * @param {string} notePath - The note path.
   * @param {OsrNoteGraph} osrNoteGraph - The OSR note graph.
   * @param {ReviewResponse} response - The review response.
   * @param {DueDateHistogram} dueDateNoteHistogram - The due date note histogram.
   * @returns {RepItemScheduleInfo} - The new schedule for the note.
   */
  noteCalcNewSchedule(notePath, osrNoteGraph, response, dueDateNoteHistogram) {
    const noteLinkStat = osrNoteGraph.calcNoteLinkStat(
      notePath,
      this.noteEaseList
    );
    const linkContribution = this.settings.maxLinkFactor * Math.min(1, Math.log(noteLinkStat.totalLinkCount + 0.5) / Math.log(64));
    let ease = (1 - linkContribution) * this.settings.baseEase + (noteLinkStat.totalLinkCount > 0 ? linkContribution * noteLinkStat.linkTotal / noteLinkStat.linkPGTotal : linkContribution * this.settings.baseEase);
    const easeByPath = this.noteEaseList.getEaseByPath(notePath);
    if (this.noteEaseList.hasEaseForPath(notePath) && easeByPath) {
      ease = (ease + easeByPath) / 2;
    }
    const interval = _SRAlgorithmOsr.initialInterval;
    ease = Math.round(ease);
    const result = this.calcSchedule(
      interval,
      ease,
      0,
      response,
      dueDateNoteHistogram
    );
    result.dueDate = (0, import_moment8.default)(globalDateProvider.today.add(result.interval, "d"));
    return result;
  }
  /**
   * Called when a note is loaded.
   *
   * @param {string} path - The note path.
   * @param {Note} note - The note.
   * @param {number} noteEase - The note ease.
   * @returns {void}
   */
  noteOnLoadedNote(path2, note, noteEase) {
    const flashcardsInNoteAvgEase = note !== null ? _SRAlgorithmOsr.calculateFlashcardAvgEase(note.questionList, this.settings) : null;
    const ease = flashcardsInNoteAvgEase && noteEase ? (flashcardsInNoteAvgEase + noteEase) / 2 : flashcardsInNoteAvgEase ? flashcardsInNoteAvgEase : noteEase;
    if (ease) {
      this.noteEaseList.setEaseForPath(path2, ease);
    }
  }
  /**
   * Calculates the average ease for a list of questions.
   *
   * @param {Question[]} questionList - The list of questions.
   * @param {SRSettings} settings - The settings object.
   * @returns {number} - The average ease for the list of questions.
   */
  static calculateFlashcardAvgEase(questionList, settings) {
    let totalEase = 0;
    let scheduledCount = 0;
    questionList.forEach((question) => {
      question.cards.filter((card) => card.hasSchedule).forEach((card) => {
        if (card.scheduleInfo !== null) {
          totalEase += card.scheduleInfo.latestEase;
          scheduledCount++;
        }
      });
    });
    let result = 0;
    if (scheduledCount > 0) {
      const flashcardsInNoteAvgEase = totalEase / scheduledCount;
      const flashcardContribution = Math.min(
        1,
        Math.log(scheduledCount + 0.5) / Math.log(64)
      );
      result = flashcardsInNoteAvgEase * flashcardContribution + settings.baseEase * (1 - flashcardContribution);
    }
    return result;
  }
  /**
   * Calculates the updated schedule for a note.
   *
   * @param {string} notePath - The note path.
   * @param {RepItemScheduleInfo} noteSchedule - The note schedule.
   * @param {ReviewResponse} response - The review response.
   * @param {DueDateHistogram} dueDateNoteHistogram - The due date note histogram.
   * @returns {RepItemScheduleInfo} - The updated schedule for the note.
   */
  noteCalcUpdatedSchedule(notePath, noteSchedule, response, dueDateNoteHistogram) {
    const noteScheduleOsr = noteSchedule;
    const temp = this.calcSchedule(
      noteScheduleOsr.interval,
      noteScheduleOsr.latestEase,
      noteScheduleOsr.delayedBeforeReviewTicks,
      response,
      dueDateNoteHistogram
    );
    const interval = temp.interval;
    const ease = temp.latestEase;
    const dueDate = (0, import_moment8.default)(globalDateProvider.today.add(interval, "d"));
    this.noteEaseList.setEaseForPath(notePath, ease);
    return new RepItemScheduleInfoOsr(dueDate, interval, ease);
  }
  /**
   * Calculates the scheduling information for a note.
   *
   * @param {RepItemScheduleInfoOsr} schedule - The scheduling information for the note.
   * @param {ReviewResponse} response - The review response.
   * @param {DueDateHistogram} dueDateHistogram - The due date histogram.
   * @returns {RepItemScheduleInfoOsr} - The scheduling information for the note.
   */
  calcSchedule(interval, latestEase, delayedBeforeReview, response, dueDateHistogram) {
    const temp = osrSchedule(
      response,
      interval,
      latestEase,
      delayedBeforeReview,
      this.settings,
      dueDateHistogram
    );
    return new RepItemScheduleInfoOsr(globalDateProvider.today, temp.interval, temp.ease);
  }
  /**
   * Gets the reset schedule for a card.
   *
   * @returns {RepItemScheduleInfo} - The reset schedule for a card.
   */
  cardGetResetSchedule() {
    const interval = _SRAlgorithmOsr.initialInterval;
    const ease = this.settings.baseEase;
    const dueDate = globalDateProvider.today;
    return new RepItemScheduleInfoOsr(dueDate, interval, ease);
  }
  /**
   * Gets the new schedule for a card.
   *
   * @param {ReviewResponse} response - The review response.
   * @param {string} notePath - The note path.
   * @param {DueDateHistogram} dueDateFlashcardHistogram - The due date flashcard histogram.
   * @returns {RepItemScheduleInfo} - The new schedule for a card.
   */
  cardGetNewSchedule(response, notePath, dueDateFlashcardHistogram) {
    let initialEase = this.settings.baseEase;
    const noteEase = this.noteEaseList.getEaseByPath(notePath);
    if (this.noteEaseList.hasEaseForPath(notePath) && noteEase !== null) {
      initialEase = Math.round(noteEase);
    }
    const delayBeforeReview = 0;
    const schedObj = osrSchedule(
      response,
      _SRAlgorithmOsr.initialInterval,
      initialEase,
      delayBeforeReview,
      this.settings,
      dueDateFlashcardHistogram
    );
    const interval = schedObj.interval;
    const ease = schedObj.ease;
    const dueDate = globalDateProvider.today.add(interval, "d");
    return new RepItemScheduleInfoOsr(dueDate, interval, ease, delayBeforeReview);
  }
  /**
   * Calculates the updated schedule for a card.
   *
   * @param {ReviewResponse} response - The review response.
   * @param {RepItemScheduleInfo} cardSchedule - The card schedule.
   * @param {DueDateHistogram} dueDateFlashcardHistogram - The due date flashcard histogram.
   * @returns {RepItemScheduleInfo} - The updated schedule for a card.
   */
  cardCalcUpdatedSchedule(response, cardSchedule, dueDateFlashcardHistogram) {
    const cardScheduleOsr = cardSchedule;
    const schedObj = osrSchedule(
      response,
      cardScheduleOsr.interval,
      cardSchedule.latestEase,
      cardSchedule.delayedBeforeReviewTicks,
      this.settings,
      dueDateFlashcardHistogram
    );
    const interval = schedObj.interval;
    const ease = schedObj.ease;
    const dueDate = globalDateProvider.today.add(interval, "d");
    const delayBeforeReview = 0;
    return new RepItemScheduleInfoOsr(dueDate, interval, ease, delayBeforeReview);
  }
  /**
   * Gets the note stats.
   *
   * @returns {INoteEaseList} - The note stats.
   */
  noteStats() {
    return this.noteEaseList;
  }
};

// src/scheduling/algorithms/fsrs/sr-algorithm-fsrs.ts
var SrsAlgorithmFsrs = class {
  constructor(settings) {
    this.algorithmType = "FSRS" /* FSRS */;
    this.noteDelegate = new SRAlgorithmOsr(settings);
    this.scheduler = fsrs(buildFsrsParameters(settings));
  }
  noteOnLoadedNote(path2, note, noteEase) {
    this.noteDelegate.noteOnLoadedNote(path2, note, noteEase);
  }
  noteCalcNewSchedule(notePath, osrNoteGraph, response, dueDateNoteHistogram) {
    return this.noteDelegate.noteCalcNewSchedule(
      notePath,
      osrNoteGraph,
      response,
      dueDateNoteHistogram
    );
  }
  noteCalcUpdatedSchedule(notePath, noteSchedule, response, dueDateNoteHistogram) {
    return this.noteDelegate.noteCalcUpdatedSchedule(
      notePath,
      noteSchedule,
      response,
      dueDateNoteHistogram
    );
  }
  noteStats() {
    return this.noteDelegate.noteStats();
  }
  cardGetResetSchedule() {
    const now2 = globalDateProvider.now.toDate();
    const emptyCard = createEmptyCard(now2);
    emptyCard.state = State.New;
    emptyCard["scheduled_days"] = 0;
    emptyCard["learning_steps"] = 0;
    emptyCard.due = now2;
    emptyCard["last_review"] = void 0;
    return RepItemScheduleInfoFsrs.fromFsrsCard(emptyCard);
  }
  cardGetNewSchedule(response, _notePath, _dueDateFlashcardHistogram) {
    const now2 = globalDateProvider.now.toDate();
    const recordLog = this.scheduler.next(
      createEmptyCard(now2),
      now2,
      reviewResponseToFsrsGrade(response)
    );
    return RepItemScheduleInfoFsrs.fromFsrsCard(recordLog.card);
  }
  cardCalcUpdatedSchedule(response, schedule, _dueDateFlashcardHistogram) {
    const now2 = globalDateProvider.now;
    const card = schedule instanceof RepItemScheduleInfoFsrs ? schedule.toFsrsCardInput(now2) : sm2ScheduleToFsrsCard(schedule, now2);
    const recordLog = this.scheduler.next(
      card,
      now2.toDate(),
      reviewResponseToFsrsGrade(response)
    );
    return RepItemScheduleInfoFsrs.fromFsrsCard(recordLog.card);
  }
};

// src/scheduling/algorithms/osr/obsidian-vault-notelink-info-finder.ts
var ObsidianVaultNoteLinkInfoFinder = class {
  // Reference to the Obsidian MetadataCache
  constructor(metadataCache) {
    this.metadataCache = metadataCache;
  }
  /**
   * Returns the resolved target links for a note path.
   *
   * @param {string} path - The note path.
   * @returns {Record<string, number>} - The resolved target links for the note path.
   */
  getResolvedTargetLinksForNotePath(path2) {
    return this.metadataCache.resolvedLinks[path2];
  }
};

// src/data/data-manager.ts
var DataManager = class {
  constructor(plugin, pluginDataManager, settingsManager) {
    // TODO: Refactor so that the plugin data manager and the settings manager are separate from the data manager
    this._osrCore = null;
    this._syncLock = false;
    this.plugin = plugin;
    this.pluginDataManager = pluginDataManager;
    this.settingsManager = settingsManager;
  }
  /**
   * Checks if the data has been loaded.
   */
  isDataLoaded() {
    return this.pluginDataManager.isLoaded;
  }
  /**
   * Checks if the OSR app core has been loaded.
   */
  isOsrCoreLoaded() {
    return this._osrCore !== null;
  }
  // TODO: Remove once everything is migrated to the settings manager and plugin data manager
  get data() {
    return this.pluginDataManager.pluginData;
  }
  set data(data) {
    this.pluginDataManager.pluginData = data;
  }
  get osrCore() {
    if (this._osrCore === null) throw new Error("SR plugin or OSR core not initialized!!!");
    return this._osrCore;
  }
  set osrCore(osrCore) {
    this._osrCore = osrCore;
  }
  get syncLock() {
    return this._syncLock;
  }
  /**
   * Loads the plugin data from the data.json from the plugin's folder.
   */
  loadData() {
    this.setupDataStoreAndAlgorithmInstances(this.settingsManager.settings);
  }
  /**
   * Initializes the OSR app core.
   *
   * @param {NoteReviewQueue} noteReviewQueue - The note review queue.
   * @param {() => void} onOsrVaultDataChanged - A callback function that is called when the OSR vault data changes.
   * @returns {Promise<void>} - A promise that resolves when the OSR app core is initialized.
   */
  async initOSRCore(noteReviewQueue, onOsrVaultDataChanged) {
    const questionPostponementList = new QuestionPostponementList(
      this.pluginDataManager,
      this.settingsManager.settings,
      this.pluginDataManager.pluginData.buryList
    );
    await questionPostponementList.clearIfNewDay(this.pluginDataManager.pluginData);
    this.osrCore = new OsrCore(
      questionPostponementList,
      new ObsidianVaultNoteLinkInfoFinder(this.plugin.app.metadataCache),
      this.settingsManager.settings,
      onOsrVaultDataChanged,
      noteReviewQueue,
      this.plugin.getObsidianRtlSetting()
    );
  }
  async loadVault() {
    if (this._syncLock) {
      return;
    }
    this._syncLock = true;
    try {
      this.osrCore.loadInitialStateOfCore();
      const notes = this.plugin.app.vault.getMarkdownFiles();
      for (const noteFile of notes) {
        if (SettingsUtil.isPathInFoldersToIgnore(
          this.settingsManager.settings,
          noteFile.path
        ))
          continue;
        const file = this.createSRNoteTFile(noteFile);
        await this.osrCore.processFile(file);
      }
      await this.osrCore.finalizeLoad();
    } finally {
      this._syncLock = false;
    }
  }
  /**
   * Creates a SRNoteTFile object from a note file.
   *
   * @param {TFile} note - The note file.
   * @returns {SRNoteTFile} - The SRNoteTFile object.
   */
  createSRNoteTFile(note) {
    return new SRNoteTFile(
      this.plugin.app.vault,
      this.plugin.app.metadataCache,
      this.plugin.app.fileManager,
      note
    );
  }
  /**
   * Sets up the data store and algorithm instances based on the settings.
   *
   * @param {SRSettings} settings - The settings object.
   */
  setupDataStoreAndAlgorithmInstances(settings) {
    switch (settings.dataStore) {
      case "NOTES" /* NOTES */:
        DataStore.instance = new NotesDataStore(
          settings,
          new NoteDataFileModifier(this.plugin)
        );
        DataStoreAlgorithm.instance = new NoteDataStoreAlgorithmOsr(settings);
        break;
    }
    SRAlgorithm.instance = settings.algorithm === "FSRS" /* FSRS */ ? new SrsAlgorithmFsrs(settings) : new SRAlgorithmOsr(settings);
  }
  /**
   * Synchronizes the data with the Obsidian vault.
   *
   * @returns {Promise<void>} - A promise that resolves when the synchronization is complete.
   */
  async sync() {
    if (this.osrCore === null) throw new Error("OSR app core not initialized!!!");
    if (this.syncLock) {
      return;
    }
    const now2 = window.moment(Date.now());
    this.osrCore.defaultTextDirection = this.plugin.getObsidianRtlSetting();
    await this.loadVault();
    if (this.settingsManager.settings.showSchedulingDebugMessages) {
      console.log(`SR: ${t("DECKS")}`, this.osrCore.reviewableDeckTree);
      console.log(
        "SR: " + t("SYNC_TIME_TAKEN", {
          t: Date.now() - now2.valueOf()
        })
      );
    }
  }
  /**
   * Loads a note from the Obsidian vault.
   *
   * @param {TFile} noteFile - The note file.
   * @returns {Promise<Note | null>} - A promise that resolves with the loaded note or null if not found.
   */
  async loadNote(noteFile) {
    const loader = new NoteFileLoader(this.settingsManager.settings);
    const srFile = this.createSRNoteTFile(noteFile);
    const folderTopicPath = TopicPath.getFolderPathFromFilename(
      srFile,
      this.settingsManager.settings
    );
    const note = await loader.load(
      this.createSRNoteTFile(noteFile),
      this.plugin.getObsidianRtlSetting(),
      folderTopicPath
    );
    if (note && note.hasChanged) {
      await note.writeNoteFile(this.settingsManager.settings);
    }
    return note;
  }
  /**
   * Saves the review response for a note.
   *
   * @param {TFile} note - The note file.
   * @param {ReviewResponse} response - The review response.
   * @returns {Promise<void>} - A promise that resolves when the review response is saved.
   */
  async saveNoteReviewResponse(note, response) {
    if (this.osrCore === null) throw new Error("OSR app core not initialized!!!");
    if (this.plugin.nextNoteReviewHandler === null)
      throw new Error("Next note review handler not initialized!!!");
    const noteSrTFile = this.createSRNoteTFile(note);
    if (SettingsUtil.isPathInFoldersToIgnore(this.settingsManager.settings, note.path)) {
      new import_obsidian36.Notice(t("NOTE_IN_IGNORED_FOLDER"));
      return;
    }
    const tags = noteSrTFile.getAllTagsFromCache();
    if (!SettingsUtil.isAnyTagANoteReviewTag(this.settingsManager.settings, tags)) {
      new import_obsidian36.Notice(t("PLEASE_TAG_NOTE"));
      return;
    }
    await this.osrCore.saveNoteReviewResponse(
      noteSrTFile,
      response,
      this.settingsManager.settings
    );
    new import_obsidian36.Notice(t("RESPONSE_RECEIVED"));
    if (this.settingsManager.settings.autoNextNote) {
      await this.plugin.nextNoteReviewHandler.autoReviewNextNote();
    }
  }
  /**
   * Saves the plugin data.
   *
   * @returns {Promise<void>} - A promise that resolves when the plugin data is saved.
   */
  async savePluginData() {
    try {
      await this.pluginDataManager.savePluginData();
    } catch (error) {
      console.warn("DataManager: Error saving plugin data", error);
    }
  }
};

// src/data/plugin-data.ts
var DEFAULT_DATA = {
  settings: DEFAULT_SETTINGS,
  buryDate: "",
  buryList: [],
  historyDeck: null,
  scheduleData: {
    version: 1,
    noteSchedules: {},
    cardSchedules: {}
  }
};

// src/data/plugin-data-manager.ts
var PluginDataError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "PluginDataError";
  }
};
var PluginDataManager = class {
  constructor(plugin) {
    this._pluginData = null;
    this.plugin = plugin;
  }
  get isLoaded() {
    return this.pluginData !== null;
  }
  get pluginData() {
    if (this._pluginData === null)
      throw new PluginDataError(
        "Cant access the plugin data, as the plugin data is not yet loaded!!"
      );
    return this._pluginData;
  }
  set pluginData(pluginData) {
    this._pluginData = pluginData;
  }
  /**
   * Loads the plugin data from the data.json from the plugin's folder.
   */
  async loadData() {
    const loadedData = await this.plugin.loadData();
    if (loadedData == null ? void 0 : loadedData.settings) upgradeSettings(loadedData.settings);
    this._pluginData = Object.assign({}, DEFAULT_DATA, loadedData);
    this._pluginData.settings = Object.assign({}, DEFAULT_SETTINGS, this._pluginData.settings);
    setDebugParser(this._pluginData.settings.showParserDebugMessages);
  }
  /**
   * Saves the plugin data.
   *
   * @returns {Promise<void>} - A promise that resolves when the plugin data is saved.
   * @throws {Error} - Throws an error if the plugin data is not loaded.
   */
  async savePluginData() {
    if (this.pluginData === null)
      throw new PluginDataError("Cant save plugin data, as the data is not yet loaded!!");
    await this.plugin.saveData(this.pluginData);
  }
  /**
   * Writes the settings to the plugin data.
   *
   * @param {SRSettings} settings - The settings to write.
   * @returns {Promise<void>} - A promise that resolves when the settings are written.
   * @throws {Error} - Throws an error if the plugin data is not loaded.
   */
  async writeSettings(settings) {
    if (this.pluginData === null)
      throw new PluginDataError(
        "Cant write settings, as the plugin data is not yet loaded!!"
      );
    this.pluginData.settings = settings;
    await this.savePluginData();
  }
};

// src/data/settings-manager.ts
var SettingsManager = class {
  constructor(settings, writeSettings) {
    this._settings = settings;
    this.writeSettings = writeSettings;
  }
  get settings() {
    return this._settings;
  }
  /**
   * Saves the settings.
   *
   * @param {SRSettings} settings - The settings to save.
   * @returns {Promise<void>} - A promise that resolves when the settings are saved.
   */
  async saveSettings(settings) {
    this._settings = settings;
    try {
      await this.writeSettings(this._settings);
    } catch (error) {
      console.warn(error);
    }
  }
  async save() {
    await this.saveSettings(this._settings);
  }
};

// src/note/next-note-review-handler.ts
var import_obsidian38 = require("obsidian");

// src/ui/obsidian-ui-components/modals/review-deck-selection-modal.tsx
var import_obsidian37 = require("obsidian");
var ReviewDeckSelectionModal = class extends import_obsidian37.FuzzySuggestModal {
  constructor(app, deckKeys) {
    super(app);
    this.deckKeys = [];
    this.deckKeys = deckKeys;
  }
  getItems() {
    return this.deckKeys;
  }
  getItemText(item) {
    return item;
  }
  onChooseItem(deckKey, _2) {
    this.close();
    this.submitCallback(deckKey);
  }
};

// src/note/next-note-review-handler.ts
var NextNoteReviewHandler = class {
  constructor(app, settings, noteReviewQueue) {
    this._lastSelectedReviewDeck = null;
    this.app = app;
    this.settings = settings;
    this._noteReviewQueue = noteReviewQueue;
  }
  get lastSelectedReviewDeck() {
    return this._lastSelectedReviewDeck;
  }
  get noteReviewQueue() {
    return this._noteReviewQueue;
  }
  async autoReviewNextNote() {
    if (this.settings.autoNextNote) {
      if (!this._lastSelectedReviewDeck) {
        const reviewDeckKeys = this._noteReviewQueue.reviewDeckNameList;
        if (reviewDeckKeys.length > 0) this._lastSelectedReviewDeck = reviewDeckKeys[0];
        else {
          new import_obsidian38.Notice(t("ALL_CAUGHT_UP"));
          return;
        }
      }
      await this.reviewNextNote(this._lastSelectedReviewDeck);
    }
  }
  async reviewNextNoteModal() {
    const reviewDeckNames = this._noteReviewQueue.reviewDeckNameList;
    if (reviewDeckNames.length === 1) {
      await this.reviewNextNote(reviewDeckNames[0]);
    } else {
      const deckSelectionModal = new ReviewDeckSelectionModal(this.app, reviewDeckNames);
      deckSelectionModal.submitCallback = (deckKey) => {
        void this.reviewNextNote(deckKey);
      };
      deckSelectionModal.open();
    }
  }
  async reviewNextNote(deckKey) {
    if (!this._noteReviewQueue.reviewDeckNameList.contains(deckKey)) {
      new import_obsidian38.Notice(t("NO_DECK_EXISTS", { deckName: deckKey }));
      return;
    }
    this._lastSelectedReviewDeck = deckKey;
    const deck = this._noteReviewQueue.reviewDecks.get(deckKey);
    if (!deck) {
      new import_obsidian38.Notice(t("NO_DECK_EXISTS", { deckName: deckKey }));
      return;
    }
    const notefile = deck.determineNextNote(this.settings.openRandomNote);
    if (notefile) {
      await this.openNote(deckKey, notefile.tfile);
    } else {
      new import_obsidian38.Notice(t("ALL_CAUGHT_UP"));
    }
  }
  async openNote(deckName, file) {
    this._lastSelectedReviewDeck = deckName;
    await this.app.workspace.getLeaf().openFile(file);
  }
};

// src/note/note-review-deck.ts
var SchedNote = class {
  constructor(note, dueUnix) {
    this.note = note;
    this.dueUnix = dueUnix;
  }
  isDue(todayUnix) {
    return this.dueUnix <= todayUnix;
  }
};
var NoteReviewDeck = class {
  constructor(name) {
    this._newNotes = [];
    this._scheduledNotes = [];
    this._dueNotesCount = 0;
    this._deckName = name;
    this._activeFolders = /* @__PURE__ */ new Set([this._deckName, t("TODAY")]);
  }
  get deckName() {
    return this._deckName;
  }
  get newNotes() {
    return this._newNotes;
  }
  get scheduledNotes() {
    return this._scheduledNotes;
  }
  get dueNotesCount() {
    return this._dueNotesCount;
  }
  get activeFolders() {
    return this._activeFolders;
  }
  calcDueNotesCount(todayUnix) {
    this._dueNotesCount = 0;
    this.scheduledNotes.forEach((scheduledNote) => {
      if (scheduledNote.isDue(todayUnix)) {
        this._dueNotesCount++;
      }
    });
  }
  sortNotesByDateAndImportance(pageranks) {
    this._newNotes = this.newNotes.sort(
      (a2, b2) => (pageranks[b2.path] || 0) - (pageranks[a2.path] || 0)
    );
    this._scheduledNotes = this.scheduledNotes.sort((a2, b2) => {
      const result = a2.dueUnix - b2.dueUnix;
      if (result !== 0) {
        return result;
      }
      return (pageranks[b2.note.path] || 0) - (pageranks[a2.note.path] || 0);
    });
  }
  determineNextNote(openRandomNote) {
    const todayUnix = globalDateProvider.today.valueOf();
    const dueNotes = this.scheduledNotes.filter((note) => note.isDue(todayUnix));
    if (dueNotes.length > 0) {
      const index = openRandomNote ? globalRandomNumberProvider.getInteger(0, dueNotes.length - 1) : 0;
      return dueNotes[index].note;
    }
    if (this.newNotes.length > 0) {
      const index = openRandomNote ? globalRandomNumberProvider.getInteger(0, this.newNotes.length - 1) : 0;
      return this.newNotes[index];
    }
    return null;
  }
};

// src/note/note-review-queue.ts
var NoteReviewQueue = class {
  get reviewDecks() {
    return this._reviewDecks;
  }
  get dueNotesCount() {
    return this._dueNotesCount;
  }
  get reviewDeckNameList() {
    return [...this._reviewDecks.keys()];
  }
  init() {
    this._reviewDecks = /* @__PURE__ */ new Map();
  }
  calcDueNotesCount(todayUnix) {
    this._dueNotesCount = 0;
    this._reviewDecks.forEach((reviewDeck) => {
      reviewDeck.calcDueNotesCount(todayUnix);
      this._dueNotesCount += reviewDeck.dueNotesCount;
    });
  }
  addNoteToQueue(noteFile, noteSchedule, matchedNoteTags) {
    for (const matchedNoteTag of matchedNoteTags) {
      if (!this.reviewDecks.has(matchedNoteTag)) {
        this.reviewDecks.set(matchedNoteTag, new NoteReviewDeck(matchedNoteTag));
      }
    }
    if (noteSchedule === null) {
      for (const matchedNoteTag of matchedNoteTags) {
        const matchedDeck = this.reviewDecks.get(matchedNoteTag);
        if (matchedDeck === void 0) continue;
        matchedDeck.newNotes.push(noteFile);
      }
    } else {
      for (const matchedNoteTag of matchedNoteTags) {
        const matchedDeck = this.reviewDecks.get(matchedNoteTag);
        if (matchedDeck === void 0) continue;
        matchedDeck.scheduledNotes.push(
          new SchedNote(noteFile, noteSchedule.dueDateAsUnix)
        );
      }
    }
  }
  updateScheduleInfo(note, scheduleInfo) {
    for (const reviewDeck of this.reviewDecks.values()) {
      const isNewNoteInDeck = reviewDeck.newNotes.some(
        (newNote) => newNote.path === note.path
      );
      const isScheduledNoteInDeck = reviewDeck.scheduledNotes.some(
        (scheduledNote) => scheduledNote.note.path === note.path
      );
      const isInDeck = isNewNoteInDeck || isScheduledNoteInDeck;
      if (!isInDeck) continue;
      if (isNewNoteInDeck) {
        const indexOfNote = reviewDeck.newNotes.findIndex(
          (newNote) => newNote.path === note.path
        );
        reviewDeck.newNotes.splice(indexOfNote, 1);
        reviewDeck.scheduledNotes.push(new SchedNote(note, scheduleInfo.dueDate.valueOf()));
      } else if (isScheduledNoteInDeck) {
        const scheduledNote = reviewDeck.scheduledNotes.find(
          (scheduledNote2) => scheduledNote2.note.path === note.path
        );
        if (scheduledNote !== void 0)
          scheduledNote.dueUnix = scheduleInfo.dueDate.valueOf();
      }
      break;
    }
  }
};

// src/scheduling/reminder-manager.ts
var ReminderManager = class {
  constructor(plugin, uiManager, dataManager) {
    this.reviewReminderTimer = null;
    this.isReviewReminderChecking = false;
    this.plugin = plugin;
    this.uiManager = uiManager;
    this.dataManager = dataManager;
  }
  /**
   * Restarts the periodic review-reminder loop once the plugin is fully initialized.
   *
   * The reminder feature depends on loaded settings, synced review data, and a ready UI.
   * Running it earlier risks duplicate startup checks or reminders based on stale state.
   */
  restartReviewReminders() {
    this.stopReviewReminders();
    this.startReviewReminders();
  }
  /**
   * Starts the periodic review-reminder loop once the plugin is fully initialized.
   *
   * The reminder feature depends on loaded settings, synced review data, and a ready UI.
   * Running it earlier risks duplicate startup checks or reminders based on stale state.
   */
  startReviewReminders() {
    if (!this.plugin.isInitialized || !this.dataManager.data.settings.enableReviewReminders) {
      return;
    }
    if (this.dataManager.data.settings.reviewReminderCheckOnStartup) {
      void this.checkReviewReminders();
    }
    const intervalMinutes = Math.min(
      Math.max(this.dataManager.data.settings.reviewReminderIntervalMinutes, 1),
      1440
    );
    this.reviewReminderTimer = window.setInterval(
      () => {
        void this.checkReviewReminders();
      },
      intervalMinutes * 60 * 1e3
    );
  }
  /**
   * Stops the reminder interval and clears the in-flight guard.
   *
   * The guard is reset here as well so that disabling and immediately re-enabling reminders
   * never leaves the scheduler stuck in a "currently checking" state.
   */
  stopReviewReminders() {
    if (this.reviewReminderTimer !== null) {
      window.clearInterval(this.reviewReminderTimer);
      this.reviewReminderTimer = null;
    }
    this.isReviewReminderChecking = false;
  }
  /**
   * Performs a single reminder check.
   *
   * We intentionally short-circuit when SR is already open, the user is editing text, or a
   * sync is already running. In those states, a reminder would be either redundant or
   * disruptive, and auto-opening review would compete with the user's current context.
   */
  async checkReviewReminders() {
    if (!this.plugin.isInitialized || !this.plugin.isDataManagerLoaded() || !this.dataManager.isOsrCoreLoaded() || this.isReviewReminderChecking || !this.dataManager.data.settings.enableReviewReminders) {
      return;
    }
    if (this.uiManager.uiState !== 0 /* Closed */ || this.uiManager.isSRInFocus) {
      return;
    }
    if (this.isUserEditingText() || this.dataManager.syncLock) {
      return;
    }
    this.isReviewReminderChecking = true;
    try {
      await this.dataManager.sync();
      const remainingDeckTree = this.dataManager.osrCore.remainingDeckTree;
      if (remainingDeckTree === null) {
        return;
      }
      const reviewCardCount = remainingDeckTree.getDistinctRepItemCount(
        2 /* AnyItem */,
        true
      );
      if (reviewCardCount <= 0 || this.uiManager.uiState !== 0 /* Closed */ || this.uiManager.isSRInFocus || this.isUserEditingText()) {
        return;
      }
      await this.uiManager.notifyReviewReminder();
      if (this.dataManager.data.settings.reviewReminderAutoOpen) {
        await this.uiManager.openDeckContainer(1 /* Review */);
      }
    } finally {
      this.isReviewReminderChecking = false;
    }
  }
  /**
   * Detects whether the user is actively typing in Obsidian.
   *
   * The reminder flow uses this to avoid stealing focus or opening review while the user is in
   * a text field, contenteditable surface, or CodeMirror-backed editor.
   */
  isUserEditingText() {
    const activeElement = activeDocument.activeElement;
    if (activeElement === null) {
      return false;
    }
    if (activeElement.instanceOf(HTMLTextAreaElement) || activeElement.instanceOf(HTMLInputElement)) {
      return true;
    }
    if (activeElement.instanceOf(HTMLElement)) {
      return activeElement.isContentEditable || activeElement.closest(".cm-editor, .markdown-source-view") !== null;
    }
    return false;
  }
};

// src/main.ts
var SRPlugin = class extends import_obsidian39.Plugin {
  constructor() {
    super(...arguments);
    this._uiManager = null;
    this._dataManager = null;
    this._nextNoteReviewHandler = null;
    this._commandManager = null;
    this._reminderManager = null;
    this.isInitialized = false;
  }
  async onload() {
    try {
      const pluginDataManager = new PluginDataManager(this);
      await pluginDataManager.loadData();
      const settingsManager = new SettingsManager(
        pluginDataManager.pluginData.settings,
        async (settings) => {
          await pluginDataManager.writeSettings(settings);
        }
      );
      this.dataManager = new DataManager(this, pluginDataManager, settingsManager);
      const uiManager = new UIManager2(this, settingsManager);
      this.uiManager = uiManager;
      this.commandManager = new CommandManager(this, settingsManager, uiManager);
      this.app.workspace.onLayoutReady(async () => {
        this.dataManager.loadData();
        if (settingsManager.settings.preferredLocale !== "-") {
          LocaleManagerInstance.getInstance().currentLocale = settingsManager.settings.preferredLocale;
        }
        const noteReviewQueue = new NoteReviewQueue();
        this._nextNoteReviewHandler = new NextNoteReviewHandler(
          this.app,
          settingsManager.settings,
          noteReviewQueue
        );
        await this.dataManager.initOSRCore(noteReviewQueue, async () => {
          await this.onOsrVaultDataChanged();
        });
        await this.uiManager.onLayoutReady();
        this.commandManager.onLayoutReady();
        this._reminderManager = new ReminderManager(this, this.uiManager, this.dataManager);
        this.isInitialized = true;
        this._reminderManager.restartReviewReminders();
      });
    } catch (error) {
      if (error instanceof PluginDataError || error instanceof Error) {
        console.warn("SRPlugin: Error in onLoad", error.message);
        DebugLoggerInstance.getInstance().log(
          "SRPlugin: Error in onLoad: " + error.message,
          "error"
        );
      } else {
        console.warn("SRPlugin: Error in onLoad");
        DebugLoggerInstance.getInstance().log("SRPlugin: Error in onLoad", "error");
      }
    }
  }
  get reminderManager() {
    if (this._reminderManager === null) throw new Error("Reminder manager not initialized!!!");
    return this._reminderManager;
  }
  get uiManager() {
    if (this._uiManager === null) throw new Error("UI manager not initialized!!!");
    return this._uiManager;
  }
  set uiManager(uiManager) {
    this._uiManager = uiManager;
  }
  get nextNoteReviewHandler() {
    if (this._nextNoteReviewHandler === null)
      throw new Error("Next note review handler not initialized!!!");
    return this._nextNoteReviewHandler;
  }
  get commandManager() {
    if (this._commandManager === null) throw new Error("Command manager not initialized!!!");
    return this._commandManager;
  }
  set commandManager(commandManager) {
    this._commandManager = commandManager;
  }
  isUiManagerLoaded() {
    return this._uiManager !== null;
  }
  get dataManager() {
    if (this._dataManager === null) throw new Error("Data manager not initialized!!!");
    return this._dataManager;
  }
  set dataManager(dataManager) {
    this._dataManager = dataManager;
  }
  isDataManagerLoaded() {
    return this._dataManager !== null;
  }
  onunload() {
    this.reminderManager.stopReviewReminders();
    this.app.workspace.getLeavesOfType(REVIEW_QUEUE_VIEW_TYPE).forEach((leaf) => leaf.detach());
    this.uiManager.destroy();
    this.commandManager.onunload();
  }
  addCustomHotkeys() {
    this.commandManager.addCustomHotkeys();
  }
  removeCustomHotkeys() {
    this.commandManager.removeCustomHotkeys();
  }
  /**
   * Gets the text direction setting for the current Obsidian instance.
   */
  getObsidianRtlSetting() {
    return activeDocument.body.hasClass("mod-rtl") ? 2 /* Rtl */ : 1 /* Ltr */;
  }
  /**
   * Called when the OSR app core's data has changed.
   *
   * Anything that needs to be updated in the UI because of this change should be done here.
   */
  async onOsrVaultDataChanged() {
    await this.uiManager.updateStatusBar();
    if (this.dataManager.data.settings.enableNoteReviewPaneOnStartup) {
      this.uiManager.sidebarManager.redraw();
    }
  }
};
/*! Bundled license information:

moment/moment.js:
  (*! moment.js *)
  (*! version : 2.30.1 *)
  (*! authors : Tim Wood, Iskren Chernev, Moment.js contributors *)
  (*! license : MIT *)
  (*! momentjs.com *)

@kurkle/color/dist/color.esm.js:
  (*!
   * @kurkle/color v0.3.4
   * https://github.com/kurkle/color#readme
   * (c) 2024 Jukka Kurkela
   * Released under the MIT License
   *)

chart.js/dist/chunks/helpers.dataset.js:
chart.js/dist/chart.js:
  (*!
   * Chart.js v4.5.1
   * https://www.chartjs.org
   * (c) 2025 Chart.js Contributors
   * Released under the MIT License
   *)

ts-fsrs/dist/index.mjs:
ts-fsrs/dist/index.mjs:
ts-fsrs/dist/index.mjs:
  (* istanbul ignore next -- @preserve *)
*/


/* nosourcemap */