ewpratten.com/content/.obsidian/plugins/obsidian-front-matter-title-plugin/main.js

/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
  if (kind && result)
    __defProp(target, key, result);
  return result;
};
var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);

// main.ts
var main_exports = {};
__export(main_exports, {
  default: () => MetaTitlePlugin
});
module.exports = __toCommonJS(main_exports);

// node_modules/reflect-metadata/Reflect.js
var Reflect2;
(function(Reflect3) {
  (function(factory) {
    var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : Function("return this;")();
    var exporter = makeExporter(Reflect3);
    if (typeof root.Reflect === "undefined") {
      root.Reflect = Reflect3;
    } else {
      exporter = makeExporter(root.Reflect, exporter);
    }
    factory(exporter);
    function makeExporter(target, previous) {
      return function(key, value) {
        if (typeof target[key] !== "function") {
          Object.defineProperty(target, key, { configurable: true, writable: true, value });
        }
        if (previous)
          previous(key, value);
      };
    }
  })(function(exporter) {
    var hasOwn = Object.prototype.hasOwnProperty;
    var supportsSymbol = typeof Symbol === "function";
    var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
    var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
    var supportsCreate = typeof Object.create === "function";
    var supportsProto = { __proto__: [] } instanceof Array;
    var downLevel = !supportsCreate && !supportsProto;
    var HashMap = {
      // create an object in dictionary mode (a.k.a. "slow" mode in v8)
      create: supportsCreate ? function() {
        return MakeDictionary(/* @__PURE__ */ Object.create(null));
      } : supportsProto ? function() {
        return MakeDictionary({ __proto__: null });
      } : function() {
        return MakeDictionary({});
      },
      has: downLevel ? function(map, key) {
        return hasOwn.call(map, key);
      } : function(map, key) {
        return key in map;
      },
      get: downLevel ? function(map, key) {
        return hasOwn.call(map, key) ? map[key] : void 0;
      } : function(map, key) {
        return map[key];
      }
    };
    var functionPrototype = Object.getPrototypeOf(Function);
    var usePolyfill = typeof process === "object" && process.env && process.env["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true";
    var _Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
    var _Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
    var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
    var Metadata2 = new _WeakMap();
    function decorate(decorators, target, propertyKey, attributes) {
      if (!IsUndefined(propertyKey)) {
        if (!IsArray(decorators))
          throw new TypeError();
        if (!IsObject(target))
          throw new TypeError();
        if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
          throw new TypeError();
        if (IsNull(attributes))
          attributes = void 0;
        propertyKey = ToPropertyKey(propertyKey);
        return DecorateProperty(decorators, target, propertyKey, attributes);
      } else {
        if (!IsArray(decorators))
          throw new TypeError();
        if (!IsConstructor(target))
          throw new TypeError();
        return DecorateConstructor(decorators, target);
      }
    }
    exporter("decorate", decorate);
    function metadata(metadataKey, metadataValue) {
      function decorator(target, propertyKey) {
        if (!IsObject(target))
          throw new TypeError();
        if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
          throw new TypeError();
        OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
      }
      return decorator;
    }
    exporter("metadata", metadata);
    function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
    }
    exporter("defineMetadata", defineMetadata);
    function hasMetadata(metadataKey, target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryHasMetadata(metadataKey, target, propertyKey);
    }
    exporter("hasMetadata", hasMetadata);
    function hasOwnMetadata(metadataKey, target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
    }
    exporter("hasOwnMetadata", hasOwnMetadata);
    function getMetadata(metadataKey, target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryGetMetadata(metadataKey, target, propertyKey);
    }
    exporter("getMetadata", getMetadata);
    function getOwnMetadata(metadataKey, target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
    }
    exporter("getOwnMetadata", getOwnMetadata);
    function getMetadataKeys(target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryMetadataKeys(target, propertyKey);
    }
    exporter("getMetadataKeys", getMetadataKeys);
    function getOwnMetadataKeys(target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      return OrdinaryOwnMetadataKeys(target, propertyKey);
    }
    exporter("getOwnMetadataKeys", getOwnMetadataKeys);
    function deleteMetadata(metadataKey, target, propertyKey) {
      if (!IsObject(target))
        throw new TypeError();
      if (!IsUndefined(propertyKey))
        propertyKey = ToPropertyKey(propertyKey);
      var metadataMap = GetOrCreateMetadataMap(
        target,
        propertyKey,
        /*Create*/
        false
      );
      if (IsUndefined(metadataMap))
        return false;
      if (!metadataMap.delete(metadataKey))
        return false;
      if (metadataMap.size > 0)
        return true;
      var targetMetadata = Metadata2.get(target);
      targetMetadata.delete(propertyKey);
      if (targetMetadata.size > 0)
        return true;
      Metadata2.delete(target);
      return true;
    }
    exporter("deleteMetadata", deleteMetadata);
    function DecorateConstructor(decorators, target) {
      for (var i = decorators.length - 1; i >= 0; --i) {
        var decorator = decorators[i];
        var decorated = decorator(target);
        if (!IsUndefined(decorated) && !IsNull(decorated)) {
          if (!IsConstructor(decorated))
            throw new TypeError();
          target = decorated;
        }
      }
      return target;
    }
    function DecorateProperty(decorators, target, propertyKey, descriptor) {
      for (var i = decorators.length - 1; i >= 0; --i) {
        var decorator = decorators[i];
        var decorated = decorator(target, propertyKey, descriptor);
        if (!IsUndefined(decorated) && !IsNull(decorated)) {
          if (!IsObject(decorated))
            throw new TypeError();
          descriptor = decorated;
        }
      }
      return descriptor;
    }
    function GetOrCreateMetadataMap(O, P, Create) {
      var targetMetadata = Metadata2.get(O);
      if (IsUndefined(targetMetadata)) {
        if (!Create)
          return void 0;
        targetMetadata = new _Map();
        Metadata2.set(O, targetMetadata);
      }
      var metadataMap = targetMetadata.get(P);
      if (IsUndefined(metadataMap)) {
        if (!Create)
          return void 0;
        metadataMap = new _Map();
        targetMetadata.set(P, metadataMap);
      }
      return metadataMap;
    }
    function OrdinaryHasMetadata(MetadataKey, O, P) {
      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
      if (hasOwn2)
        return true;
      var parent = OrdinaryGetPrototypeOf(O);
      if (!IsNull(parent))
        return OrdinaryHasMetadata(MetadataKey, parent, P);
      return false;
    }
    function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
      var metadataMap = GetOrCreateMetadataMap(
        O,
        P,
        /*Create*/
        false
      );
      if (IsUndefined(metadataMap))
        return false;
      return ToBoolean(metadataMap.has(MetadataKey));
    }
    function OrdinaryGetMetadata(MetadataKey, O, P) {
      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
      if (hasOwn2)
        return OrdinaryGetOwnMetadata(MetadataKey, O, P);
      var parent = OrdinaryGetPrototypeOf(O);
      if (!IsNull(parent))
        return OrdinaryGetMetadata(MetadataKey, parent, P);
      return void 0;
    }
    function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
      var metadataMap = GetOrCreateMetadataMap(
        O,
        P,
        /*Create*/
        false
      );
      if (IsUndefined(metadataMap))
        return void 0;
      return metadataMap.get(MetadataKey);
    }
    function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
      var metadataMap = GetOrCreateMetadataMap(
        O,
        P,
        /*Create*/
        true
      );
      metadataMap.set(MetadataKey, MetadataValue);
    }
    function OrdinaryMetadataKeys(O, P) {
      var ownKeys = OrdinaryOwnMetadataKeys(O, P);
      var parent = OrdinaryGetPrototypeOf(O);
      if (parent === null)
        return ownKeys;
      var parentKeys = OrdinaryMetadataKeys(parent, P);
      if (parentKeys.length <= 0)
        return ownKeys;
      if (ownKeys.length <= 0)
        return parentKeys;
      var set = new _Set();
      var keys = [];
      for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
        var key = ownKeys_1[_i];
        var hasKey = set.has(key);
        if (!hasKey) {
          set.add(key);
          keys.push(key);
        }
      }
      for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
        var key = parentKeys_1[_a];
        var hasKey = set.has(key);
        if (!hasKey) {
          set.add(key);
          keys.push(key);
        }
      }
      return keys;
    }
    function OrdinaryOwnMetadataKeys(O, P) {
      var keys = [];
      var metadataMap = GetOrCreateMetadataMap(
        O,
        P,
        /*Create*/
        false
      );
      if (IsUndefined(metadataMap))
        return keys;
      var keysObj = metadataMap.keys();
      var iterator = GetIterator(keysObj);
      var k = 0;
      while (true) {
        var next = IteratorStep(iterator);
        if (!next) {
          keys.length = k;
          return keys;
        }
        var nextValue = IteratorValue(next);
        try {
          keys[k] = nextValue;
        } catch (e) {
          try {
            IteratorClose(iterator);
          } finally {
            throw e;
          }
        }
        k++;
      }
    }
    function Type(x) {
      if (x === null)
        return 1;
      switch (typeof x) {
        case "undefined":
          return 0;
        case "boolean":
          return 2;
        case "string":
          return 3;
        case "symbol":
          return 4;
        case "number":
          return 5;
        case "object":
          return x === null ? 1 : 6;
        default:
          return 6;
      }
    }
    function IsUndefined(x) {
      return x === void 0;
    }
    function IsNull(x) {
      return x === null;
    }
    function IsSymbol(x) {
      return typeof x === "symbol";
    }
    function IsObject(x) {
      return typeof x === "object" ? x !== null : typeof x === "function";
    }
    function ToPrimitive(input, PreferredType) {
      switch (Type(input)) {
        case 0:
          return input;
        case 1:
          return input;
        case 2:
          return input;
        case 3:
          return input;
        case 4:
          return input;
        case 5:
          return input;
      }
      var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
      var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
      if (exoticToPrim !== void 0) {
        var result = exoticToPrim.call(input, hint);
        if (IsObject(result))
          throw new TypeError();
        return result;
      }
      return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
    }
    function OrdinaryToPrimitive(O, hint) {
      if (hint === "string") {
        var toString_1 = O.toString;
        if (IsCallable(toString_1)) {
          var result = toString_1.call(O);
          if (!IsObject(result))
            return result;
        }
        var valueOf = O.valueOf;
        if (IsCallable(valueOf)) {
          var result = valueOf.call(O);
          if (!IsObject(result))
            return result;
        }
      } else {
        var valueOf = O.valueOf;
        if (IsCallable(valueOf)) {
          var result = valueOf.call(O);
          if (!IsObject(result))
            return result;
        }
        var toString_2 = O.toString;
        if (IsCallable(toString_2)) {
          var result = toString_2.call(O);
          if (!IsObject(result))
            return result;
        }
      }
      throw new TypeError();
    }
    function ToBoolean(argument) {
      return !!argument;
    }
    function ToString(argument) {
      return "" + argument;
    }
    function ToPropertyKey(argument) {
      var key = ToPrimitive(
        argument,
        3
        /* String */
      );
      if (IsSymbol(key))
        return key;
      return ToString(key);
    }
    function IsArray(argument) {
      return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
    }
    function IsCallable(argument) {
      return typeof argument === "function";
    }
    function IsConstructor(argument) {
      return typeof argument === "function";
    }
    function IsPropertyKey(argument) {
      switch (Type(argument)) {
        case 3:
          return true;
        case 4:
          return true;
        default:
          return false;
      }
    }
    function GetMethod(V, P) {
      var func = V[P];
      if (func === void 0 || func === null)
        return void 0;
      if (!IsCallable(func))
        throw new TypeError();
      return func;
    }
    function GetIterator(obj) {
      var method = GetMethod(obj, iteratorSymbol);
      if (!IsCallable(method))
        throw new TypeError();
      var iterator = method.call(obj);
      if (!IsObject(iterator))
        throw new TypeError();
      return iterator;
    }
    function IteratorValue(iterResult) {
      return iterResult.value;
    }
    function IteratorStep(iterator) {
      var result = iterator.next();
      return result.done ? false : result;
    }
    function IteratorClose(iterator) {
      var f = iterator["return"];
      if (f)
        f.call(iterator);
    }
    function OrdinaryGetPrototypeOf(O) {
      var proto = Object.getPrototypeOf(O);
      if (typeof O !== "function" || O === functionPrototype)
        return proto;
      if (proto !== functionPrototype)
        return proto;
      var prototype = O.prototype;
      var prototypeProto = prototype && Object.getPrototypeOf(prototype);
      if (prototypeProto == null || prototypeProto === Object.prototype)
        return proto;
      var constructor = prototypeProto.constructor;
      if (typeof constructor !== "function")
        return proto;
      if (constructor === O)
        return proto;
      return constructor;
    }
    function CreateMapPolyfill() {
      var cacheSentinel = {};
      var arraySentinel = [];
      var MapIterator = (
        /** @class */
        function() {
          function MapIterator2(keys, values, selector) {
            this._index = 0;
            this._keys = keys;
            this._values = values;
            this._selector = selector;
          }
          MapIterator2.prototype["@@iterator"] = function() {
            return this;
          };
          MapIterator2.prototype[iteratorSymbol] = function() {
            return this;
          };
          MapIterator2.prototype.next = function() {
            var index = this._index;
            if (index >= 0 && index < this._keys.length) {
              var result = this._selector(this._keys[index], this._values[index]);
              if (index + 1 >= this._keys.length) {
                this._index = -1;
                this._keys = arraySentinel;
                this._values = arraySentinel;
              } else {
                this._index++;
              }
              return { value: result, done: false };
            }
            return { value: void 0, done: true };
          };
          MapIterator2.prototype.throw = function(error) {
            if (this._index >= 0) {
              this._index = -1;
              this._keys = arraySentinel;
              this._values = arraySentinel;
            }
            throw error;
          };
          MapIterator2.prototype.return = function(value) {
            if (this._index >= 0) {
              this._index = -1;
              this._keys = arraySentinel;
              this._values = arraySentinel;
            }
            return { value, done: true };
          };
          return MapIterator2;
        }()
      );
      return (
        /** @class */
        function() {
          function Map2() {
            this._keys = [];
            this._values = [];
            this._cacheKey = cacheSentinel;
            this._cacheIndex = -2;
          }
          Object.defineProperty(Map2.prototype, "size", {
            get: function() {
              return this._keys.length;
            },
            enumerable: true,
            configurable: true
          });
          Map2.prototype.has = function(key) {
            return this._find(
              key,
              /*insert*/
              false
            ) >= 0;
          };
          Map2.prototype.get = function(key) {
            var index = this._find(
              key,
              /*insert*/
              false
            );
            return index >= 0 ? this._values[index] : void 0;
          };
          Map2.prototype.set = function(key, value) {
            var index = this._find(
              key,
              /*insert*/
              true
            );
            this._values[index] = value;
            return this;
          };
          Map2.prototype.delete = function(key) {
            var index = this._find(
              key,
              /*insert*/
              false
            );
            if (index >= 0) {
              var size = this._keys.length;
              for (var i = index + 1; i < size; i++) {
                this._keys[i - 1] = this._keys[i];
                this._values[i - 1] = this._values[i];
              }
              this._keys.length--;
              this._values.length--;
              if (key === this._cacheKey) {
                this._cacheKey = cacheSentinel;
                this._cacheIndex = -2;
              }
              return true;
            }
            return false;
          };
          Map2.prototype.clear = function() {
            this._keys.length = 0;
            this._values.length = 0;
            this._cacheKey = cacheSentinel;
            this._cacheIndex = -2;
          };
          Map2.prototype.keys = function() {
            return new MapIterator(this._keys, this._values, getKey);
          };
          Map2.prototype.values = function() {
            return new MapIterator(this._keys, this._values, getValue);
          };
          Map2.prototype.entries = function() {
            return new MapIterator(this._keys, this._values, getEntry);
          };
          Map2.prototype["@@iterator"] = function() {
            return this.entries();
          };
          Map2.prototype[iteratorSymbol] = function() {
            return this.entries();
          };
          Map2.prototype._find = function(key, insert) {
            if (this._cacheKey !== key) {
              this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
            }
            if (this._cacheIndex < 0 && insert) {
              this._cacheIndex = this._keys.length;
              this._keys.push(key);
              this._values.push(void 0);
            }
            return this._cacheIndex;
          };
          return Map2;
        }()
      );
      function getKey(key, _) {
        return key;
      }
      function getValue(_, value) {
        return value;
      }
      function getEntry(key, value) {
        return [key, value];
      }
    }
    function CreateSetPolyfill() {
      return (
        /** @class */
        function() {
          function Set2() {
            this._map = new _Map();
          }
          Object.defineProperty(Set2.prototype, "size", {
            get: function() {
              return this._map.size;
            },
            enumerable: true,
            configurable: true
          });
          Set2.prototype.has = function(value) {
            return this._map.has(value);
          };
          Set2.prototype.add = function(value) {
            return this._map.set(value, value), this;
          };
          Set2.prototype.delete = function(value) {
            return this._map.delete(value);
          };
          Set2.prototype.clear = function() {
            this._map.clear();
          };
          Set2.prototype.keys = function() {
            return this._map.keys();
          };
          Set2.prototype.values = function() {
            return this._map.values();
          };
          Set2.prototype.entries = function() {
            return this._map.entries();
          };
          Set2.prototype["@@iterator"] = function() {
            return this.keys();
          };
          Set2.prototype[iteratorSymbol] = function() {
            return this.keys();
          };
          return Set2;
        }()
      );
    }
    function CreateWeakMapPolyfill() {
      var UUID_SIZE = 16;
      var keys = HashMap.create();
      var rootKey = CreateUniqueKey();
      return (
        /** @class */
        function() {
          function WeakMap2() {
            this._key = CreateUniqueKey();
          }
          WeakMap2.prototype.has = function(target) {
            var table = GetOrCreateWeakMapTable(
              target,
              /*create*/
              false
            );
            return table !== void 0 ? HashMap.has(table, this._key) : false;
          };
          WeakMap2.prototype.get = function(target) {
            var table = GetOrCreateWeakMapTable(
              target,
              /*create*/
              false
            );
            return table !== void 0 ? HashMap.get(table, this._key) : void 0;
          };
          WeakMap2.prototype.set = function(target, value) {
            var table = GetOrCreateWeakMapTable(
              target,
              /*create*/
              true
            );
            table[this._key] = value;
            return this;
          };
          WeakMap2.prototype.delete = function(target) {
            var table = GetOrCreateWeakMapTable(
              target,
              /*create*/
              false
            );
            return table !== void 0 ? delete table[this._key] : false;
          };
          WeakMap2.prototype.clear = function() {
            this._key = CreateUniqueKey();
          };
          return WeakMap2;
        }()
      );
      function CreateUniqueKey() {
        var key;
        do
          key = "@@WeakMap@@" + CreateUUID();
        while (HashMap.has(keys, key));
        keys[key] = true;
        return key;
      }
      function GetOrCreateWeakMapTable(target, create2) {
        if (!hasOwn.call(target, rootKey)) {
          if (!create2)
            return void 0;
          Object.defineProperty(target, rootKey, { value: HashMap.create() });
        }
        return target[rootKey];
      }
      function FillRandomBytes(buffer, size) {
        for (var i = 0; i < size; ++i)
          buffer[i] = Math.random() * 255 | 0;
        return buffer;
      }
      function GenRandomBytes(size) {
        if (typeof Uint8Array === "function") {
          if (typeof crypto !== "undefined")
            return crypto.getRandomValues(new Uint8Array(size));
          if (typeof msCrypto !== "undefined")
            return msCrypto.getRandomValues(new Uint8Array(size));
          return FillRandomBytes(new Uint8Array(size), size);
        }
        return FillRandomBytes(new Array(size), size);
      }
      function CreateUUID() {
        var data = GenRandomBytes(UUID_SIZE);
        data[6] = data[6] & 79 | 64;
        data[8] = data[8] & 191 | 128;
        var result = "";
        for (var offset = 0; offset < UUID_SIZE; ++offset) {
          var byte = data[offset];
          if (offset === 4 || offset === 6 || offset === 8)
            result += "-";
          if (byte < 16)
            result += "0";
          result += byte.toString(16).toLowerCase();
        }
        return result;
      }
    }
    function MakeDictionary(obj) {
      obj.__ = void 0;
      delete obj.__;
      return obj;
    }
  });
})(Reflect2 || (Reflect2 = {}));

// main.ts
var import_obsidian17 = require("obsidian");

// src/Settings/SettingsTab.ts
var import_obsidian2 = require("obsidian");

// src/Components/EventDispatcher/Event.ts
var Event = class {
  constructor(data) {
    this.data = data;
  }
  get() {
    return this.data;
  }
  stop() {
    return;
  }
};

// src/Utils/ObjectHelper.ts
var ObjectHelper = class _ObjectHelper {
  static compare(old = {}, actual = {}) {
    const changed = {};
    const keys = [...Object.keys(old), ...Object.keys(actual)].filter((e, i, s) => s.indexOf(e) === i);
    for (const k of keys) {
      const first = old[k];
      const second = actual[k];
      const type = typeof (first !== void 0 ? first : second);
      const thereIsNull = first === null || second === null;
      if (type === "object" && !thereIsNull) {
        if (Array.isArray(first)) {
          const hasDiff = first.some((x) => !second.includes(x));
          const isChanged = hasDiff ? true : second.some((x) => !first.includes(x));
          if (isChanged) {
            changed[k] = true;
          }
        } else {
          const c = _ObjectHelper.compare(first, second);
          if (Object.values(c).some((e) => e !== false)) {
            changed[k] = c;
          }
        }
      } else {
        if (first !== second) {
          changed[k] = true;
        }
      }
    }
    return changed;
  }
  static fillFrom(to, from) {
    for (const [k, v] of Object.entries(to)) {
      const fv = from[k];
      if (fv === void 0) {
        continue;
      }
      const type = typeof v;
      if (type === "object" && !Array.isArray(fv) && v !== null) {
        if (fv !== null) {
          _ObjectHelper.fillFrom(v, fv);
        }
        continue;
      }
      to[k] = fv;
    }
    return to;
  }
  static entries(object) {
    return Object.entries(object);
  }
  static values(object) {
    return Object.values(object);
  }
};

// node_modules/inversify/es/constants/metadata_keys.js
var NAMED_TAG = "named";
var NAME_TAG = "name";
var UNMANAGED_TAG = "unmanaged";
var OPTIONAL_TAG = "optional";
var INJECT_TAG = "inject";
var MULTI_INJECT_TAG = "multi_inject";
var TAGGED = "inversify:tagged";
var TAGGED_PROP = "inversify:tagged_props";
var PARAM_TYPES = "inversify:paramtypes";
var DESIGN_PARAM_TYPES = "design:paramtypes";
var POST_CONSTRUCT = "post_construct";
var PRE_DESTROY = "pre_destroy";
function getNonCustomTagKeys() {
  return [
    INJECT_TAG,
    MULTI_INJECT_TAG,
    NAME_TAG,
    UNMANAGED_TAG,
    NAMED_TAG,
    OPTIONAL_TAG
  ];
}
var NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys();

// node_modules/inversify/es/constants/literal_types.js
var BindingScopeEnum = {
  Request: "Request",
  Singleton: "Singleton",
  Transient: "Transient"
};
var BindingTypeEnum = {
  ConstantValue: "ConstantValue",
  Constructor: "Constructor",
  DynamicValue: "DynamicValue",
  Factory: "Factory",
  Function: "Function",
  Instance: "Instance",
  Invalid: "Invalid",
  Provider: "Provider"
};
var TargetTypeEnum = {
  ClassProperty: "ClassProperty",
  ConstructorArgument: "ConstructorArgument",
  Variable: "Variable"
};

// node_modules/inversify/es/utils/id.js
var idCounter = 0;
function id() {
  return idCounter++;
}

// node_modules/inversify/es/bindings/binding.js
var Binding = function() {
  function Binding2(serviceIdentifier, scope) {
    this.id = id();
    this.activated = false;
    this.serviceIdentifier = serviceIdentifier;
    this.scope = scope;
    this.type = BindingTypeEnum.Invalid;
    this.constraint = function(request) {
      return true;
    };
    this.implementationType = null;
    this.cache = null;
    this.factory = null;
    this.provider = null;
    this.onActivation = null;
    this.onDeactivation = null;
    this.dynamicValue = null;
  }
  Binding2.prototype.clone = function() {
    var clone = new Binding2(this.serviceIdentifier, this.scope);
    clone.activated = clone.scope === BindingScopeEnum.Singleton ? this.activated : false;
    clone.implementationType = this.implementationType;
    clone.dynamicValue = this.dynamicValue;
    clone.scope = this.scope;
    clone.type = this.type;
    clone.factory = this.factory;
    clone.provider = this.provider;
    clone.constraint = this.constraint;
    clone.onActivation = this.onActivation;
    clone.onDeactivation = this.onDeactivation;
    clone.cache = this.cache;
    return clone;
  };
  return Binding2;
}();

// node_modules/inversify/es/constants/error_msgs.js
var DUPLICATED_INJECTABLE_DECORATOR = "Cannot apply @injectable decorator multiple times.";
var DUPLICATED_METADATA = "Metadata key was used more than once in a parameter:";
var NULL_ARGUMENT = "NULL argument";
var KEY_NOT_FOUND = "Key Not Found";
var AMBIGUOUS_MATCH = "Ambiguous match found for serviceIdentifier:";
var CANNOT_UNBIND = "Could not unbind serviceIdentifier:";
var NOT_REGISTERED = "No matching bindings found for serviceIdentifier:";
var MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:";
var MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:";
var UNDEFINED_INJECT_ANNOTATION = function(name) {
  return "@inject called with undefined this could mean that the class " + name + " has a circular dependency problem. You can use a LazyServiceIdentifer to  overcome this limitation.";
};
var CIRCULAR_DEPENDENCY = "Circular dependency found:";
var INVALID_BINDING_TYPE = "Invalid binding type:";
var NO_MORE_SNAPSHOTS_AVAILABLE = "No snapshot available to restore.";
var INVALID_MIDDLEWARE_RETURN = "Invalid return type in middleware. Middleware must return!";
var INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!";
var LAZY_IN_SYNC = function(key) {
  return "You are attempting to construct '" + key + "' in a synchronous way\n but it has asynchronous dependencies.";
};
var INVALID_TO_SELF_VALUE = "The toSelf function can only be applied when a constructor is used as service identifier";
var INVALID_DECORATOR_OPERATION = "The @inject @multiInject @tagged and @named decorators must be applied to the parameters of a class constructor or a class property.";
var ARGUMENTS_LENGTH_MISMATCH = function() {
  var values = [];
  for (var _i = 0; _i < arguments.length; _i++) {
    values[_i] = arguments[_i];
  }
  return "The number of constructor arguments in the derived class " + (values[0] + " must be >= than the number of constructor arguments of its base class.");
};
var CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = "Invalid Container constructor argument. Container options must be an object.";
var CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = "Invalid Container option. Default scope must be a string ('singleton' or 'transient').";
var CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = "Invalid Container option. Auto bind injectable must be a boolean";
var CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = "Invalid Container option. Skip base check must be a boolean";
var ASYNC_UNBIND_REQUIRED = "Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)";
var POST_CONSTRUCT_ERROR = function(clazz, errorMessage) {
  return "@postConstruct error in class " + clazz + ": " + errorMessage;
};
var PRE_DESTROY_ERROR = function(clazz, errorMessage) {
  return "@preDestroy error in class " + clazz + ": " + errorMessage;
};
var ON_DEACTIVATION_ERROR = function(clazz, errorMessage) {
  return "onDeactivation() error in class " + clazz + ": " + errorMessage;
};
var CIRCULAR_DEPENDENCY_IN_FACTORY = function(factoryType, serviceIdentifier) {
  return "It looks like there is a circular dependency in one of the '" + factoryType + "' bindings. Please investigate bindings with" + ("service identifier '" + serviceIdentifier + "'.");
};
var STACK_OVERFLOW = "Maximum call stack size exceeded";

// node_modules/inversify/es/planning/metadata_reader.js
var MetadataReader = function() {
  function MetadataReader2() {
  }
  MetadataReader2.prototype.getConstructorMetadata = function(constructorFunc) {
    var compilerGeneratedMetadata = Reflect.getMetadata(PARAM_TYPES, constructorFunc);
    var userGeneratedMetadata = Reflect.getMetadata(TAGGED, constructorFunc);
    return {
      compilerGeneratedMetadata,
      userGeneratedMetadata: userGeneratedMetadata || {}
    };
  };
  MetadataReader2.prototype.getPropertiesMetadata = function(constructorFunc) {
    var userGeneratedMetadata = Reflect.getMetadata(TAGGED_PROP, constructorFunc) || [];
    return userGeneratedMetadata;
  };
  return MetadataReader2;
}();

// node_modules/inversify/es/bindings/binding_count.js
var BindingCount = {
  MultipleBindingsAvailable: 2,
  NoBindingsAvailable: 0,
  OnlyOneBindingAvailable: 1
};

// node_modules/inversify/es/utils/exceptions.js
function isStackOverflowExeption(error) {
  return error instanceof RangeError || error.message === STACK_OVERFLOW;
}
var tryAndThrowErrorIfStackOverflow = function(fn, errorCallback) {
  try {
    return fn();
  } catch (error) {
    if (isStackOverflowExeption(error)) {
      error = errorCallback();
    }
    throw error;
  }
};

// node_modules/inversify/es/utils/serialization.js
function getServiceIdentifierAsString(serviceIdentifier) {
  if (typeof serviceIdentifier === "function") {
    var _serviceIdentifier = serviceIdentifier;
    return _serviceIdentifier.name;
  } else if (typeof serviceIdentifier === "symbol") {
    return serviceIdentifier.toString();
  } else {
    var _serviceIdentifier = serviceIdentifier;
    return _serviceIdentifier;
  }
}
function listRegisteredBindingsForServiceIdentifier(container, serviceIdentifier, getBindings2) {
  var registeredBindingsList = "";
  var registeredBindings = getBindings2(container, serviceIdentifier);
  if (registeredBindings.length !== 0) {
    registeredBindingsList = "\nRegistered bindings:";
    registeredBindings.forEach(function(binding) {
      var name = "Object";
      if (binding.implementationType !== null) {
        name = getFunctionName(binding.implementationType);
      }
      registeredBindingsList = registeredBindingsList + "\n " + name;
      if (binding.constraint.metaData) {
        registeredBindingsList = registeredBindingsList + " - " + binding.constraint.metaData;
      }
    });
  }
  return registeredBindingsList;
}
function alreadyDependencyChain(request, serviceIdentifier) {
  if (request.parentRequest === null) {
    return false;
  } else if (request.parentRequest.serviceIdentifier === serviceIdentifier) {
    return true;
  } else {
    return alreadyDependencyChain(request.parentRequest, serviceIdentifier);
  }
}
function dependencyChainToString(request) {
  function _createStringArr(req, result) {
    if (result === void 0) {
      result = [];
    }
    var serviceIdentifier = getServiceIdentifierAsString(req.serviceIdentifier);
    result.push(serviceIdentifier);
    if (req.parentRequest !== null) {
      return _createStringArr(req.parentRequest, result);
    }
    return result;
  }
  var stringArr = _createStringArr(request);
  return stringArr.reverse().join(" --> ");
}
function circularDependencyToException(request) {
  request.childRequests.forEach(function(childRequest) {
    if (alreadyDependencyChain(childRequest, childRequest.serviceIdentifier)) {
      var services = dependencyChainToString(childRequest);
      throw new Error(CIRCULAR_DEPENDENCY + " " + services);
    } else {
      circularDependencyToException(childRequest);
    }
  });
}
function listMetadataForTarget(serviceIdentifierString, target) {
  if (target.isTagged() || target.isNamed()) {
    var m_1 = "";
    var namedTag = target.getNamedTag();
    var otherTags = target.getCustomTags();
    if (namedTag !== null) {
      m_1 += namedTag.toString() + "\n";
    }
    if (otherTags !== null) {
      otherTags.forEach(function(tag) {
        m_1 += tag.toString() + "\n";
      });
    }
    return " " + serviceIdentifierString + "\n " + serviceIdentifierString + " - " + m_1;
  } else {
    return " " + serviceIdentifierString;
  }
}
function getFunctionName(func) {
  if (func.name) {
    return func.name;
  } else {
    var name_1 = func.toString();
    var match = name_1.match(/^function\s*([^\s(]+)/);
    return match ? match[1] : "Anonymous function: " + name_1;
  }
}
function getSymbolDescription(symbol) {
  return symbol.toString().slice(7, -1);
}

// node_modules/inversify/es/planning/context.js
var Context = function() {
  function Context2(container) {
    this.id = id();
    this.container = container;
  }
  Context2.prototype.addPlan = function(plan2) {
    this.plan = plan2;
  };
  Context2.prototype.setCurrentRequest = function(currentRequest) {
    this.currentRequest = currentRequest;
  };
  return Context2;
}();

// node_modules/inversify/es/planning/metadata.js
var Metadata = function() {
  function Metadata2(key, value) {
    this.key = key;
    this.value = value;
  }
  Metadata2.prototype.toString = function() {
    if (this.key === NAMED_TAG) {
      return "named: " + String(this.value).toString() + " ";
    } else {
      return "tagged: { key:" + this.key.toString() + ", value: " + String(this.value) + " }";
    }
  };
  return Metadata2;
}();

// node_modules/inversify/es/planning/plan.js
var Plan = function() {
  function Plan2(parentContext, rootRequest) {
    this.parentContext = parentContext;
    this.rootRequest = rootRequest;
  }
  return Plan2;
}();

// node_modules/inversify/es/annotation/lazy_service_identifier.js
var LazyServiceIdentifer = function() {
  function LazyServiceIdentifer2(cb) {
    this._cb = cb;
  }
  LazyServiceIdentifer2.prototype.unwrap = function() {
    return this._cb();
  };
  return LazyServiceIdentifer2;
}();

// node_modules/inversify/es/planning/queryable_string.js
var QueryableString = function() {
  function QueryableString2(str) {
    this.str = str;
  }
  QueryableString2.prototype.startsWith = function(searchString) {
    return this.str.indexOf(searchString) === 0;
  };
  QueryableString2.prototype.endsWith = function(searchString) {
    var reverseString = "";
    var reverseSearchString = searchString.split("").reverse().join("");
    reverseString = this.str.split("").reverse().join("");
    return this.startsWith.call({ str: reverseString }, reverseSearchString);
  };
  QueryableString2.prototype.contains = function(searchString) {
    return this.str.indexOf(searchString) !== -1;
  };
  QueryableString2.prototype.equals = function(compareString) {
    return this.str === compareString;
  };
  QueryableString2.prototype.value = function() {
    return this.str;
  };
  return QueryableString2;
}();

// node_modules/inversify/es/planning/target.js
var Target = function() {
  function Target2(type, identifier, serviceIdentifier, namedOrTagged) {
    this.id = id();
    this.type = type;
    this.serviceIdentifier = serviceIdentifier;
    var queryableName = typeof identifier === "symbol" ? getSymbolDescription(identifier) : identifier;
    this.name = new QueryableString(queryableName || "");
    this.identifier = identifier;
    this.metadata = new Array();
    var metadataItem = null;
    if (typeof namedOrTagged === "string") {
      metadataItem = new Metadata(NAMED_TAG, namedOrTagged);
    } else if (namedOrTagged instanceof Metadata) {
      metadataItem = namedOrTagged;
    }
    if (metadataItem !== null) {
      this.metadata.push(metadataItem);
    }
  }
  Target2.prototype.hasTag = function(key) {
    for (var _i = 0, _a = this.metadata; _i < _a.length; _i++) {
      var m = _a[_i];
      if (m.key === key) {
        return true;
      }
    }
    return false;
  };
  Target2.prototype.isArray = function() {
    return this.hasTag(MULTI_INJECT_TAG);
  };
  Target2.prototype.matchesArray = function(name) {
    return this.matchesTag(MULTI_INJECT_TAG)(name);
  };
  Target2.prototype.isNamed = function() {
    return this.hasTag(NAMED_TAG);
  };
  Target2.prototype.isTagged = function() {
    return this.metadata.some(function(metadata) {
      return NON_CUSTOM_TAG_KEYS.every(function(key) {
        return metadata.key !== key;
      });
    });
  };
  Target2.prototype.isOptional = function() {
    return this.matchesTag(OPTIONAL_TAG)(true);
  };
  Target2.prototype.getNamedTag = function() {
    if (this.isNamed()) {
      return this.metadata.filter(function(m) {
        return m.key === NAMED_TAG;
      })[0];
    }
    return null;
  };
  Target2.prototype.getCustomTags = function() {
    if (this.isTagged()) {
      return this.metadata.filter(function(metadata) {
        return NON_CUSTOM_TAG_KEYS.every(function(key) {
          return metadata.key !== key;
        });
      });
    } else {
      return null;
    }
  };
  Target2.prototype.matchesNamedTag = function(name) {
    return this.matchesTag(NAMED_TAG)(name);
  };
  Target2.prototype.matchesTag = function(key) {
    var _this = this;
    return function(value) {
      for (var _i = 0, _a = _this.metadata; _i < _a.length; _i++) {
        var m = _a[_i];
        if (m.key === key && m.value === value) {
          return true;
        }
      }
      return false;
    };
  };
  return Target2;
}();

// node_modules/inversify/es/planning/reflection_utils.js
var __spreadArray = function(to, from, pack) {
  if (pack || arguments.length === 2)
    for (var i = 0, l = from.length, ar; i < l; i++) {
      if (ar || !(i in from)) {
        if (!ar)
          ar = Array.prototype.slice.call(from, 0, i);
        ar[i] = from[i];
      }
    }
  return to.concat(ar || Array.prototype.slice.call(from));
};
function getDependencies(metadataReader, func) {
  var constructorName = getFunctionName(func);
  return getTargets(metadataReader, constructorName, func, false);
}
function getTargets(metadataReader, constructorName, func, isBaseClass) {
  var metadata = metadataReader.getConstructorMetadata(func);
  var serviceIdentifiers = metadata.compilerGeneratedMetadata;
  if (serviceIdentifiers === void 0) {
    var msg = MISSING_INJECTABLE_ANNOTATION + " " + constructorName + ".";
    throw new Error(msg);
  }
  var constructorArgsMetadata = metadata.userGeneratedMetadata;
  var keys = Object.keys(constructorArgsMetadata);
  var hasUserDeclaredUnknownInjections = func.length === 0 && keys.length > 0;
  var hasOptionalParameters = keys.length > func.length;
  var iterations = hasUserDeclaredUnknownInjections || hasOptionalParameters ? keys.length : func.length;
  var constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);
  var propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName);
  var targets = __spreadArray(__spreadArray([], constructorTargets, true), propertyTargets, true);
  return targets;
}
function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
  var targetMetadata = constructorArgsMetadata[index.toString()] || [];
  var metadata = formatTargetMetadata(targetMetadata);
  var isManaged = metadata.unmanaged !== true;
  var serviceIdentifier = serviceIdentifiers[index];
  var injectIdentifier = metadata.inject || metadata.multiInject;
  serviceIdentifier = injectIdentifier ? injectIdentifier : serviceIdentifier;
  if (serviceIdentifier instanceof LazyServiceIdentifer) {
    serviceIdentifier = serviceIdentifier.unwrap();
  }
  if (isManaged) {
    var isObject = serviceIdentifier === Object;
    var isFunction = serviceIdentifier === Function;
    var isUndefined = serviceIdentifier === void 0;
    var isUnknownType = isObject || isFunction || isUndefined;
    if (!isBaseClass && isUnknownType) {
      var msg = MISSING_INJECT_ANNOTATION + " argument " + index + " in class " + constructorName + ".";
      throw new Error(msg);
    }
    var target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
    target.metadata = targetMetadata;
    return target;
  }
  return null;
}
function getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {
  var targets = [];
  for (var i = 0; i < iterations; i++) {
    var index = i;
    var target = getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);
    if (target !== null) {
      targets.push(target);
    }
  }
  return targets;
}
function _getServiceIdentifierForProperty(inject2, multiInject2, propertyName, className) {
  var serviceIdentifier = inject2 || multiInject2;
  if (serviceIdentifier === void 0) {
    var msg = MISSING_INJECTABLE_ANNOTATION + " for property " + String(propertyName) + " in class " + className + ".";
    throw new Error(msg);
  }
  return serviceIdentifier;
}
function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) {
  var classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
  var targets = [];
  var symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata);
  var stringKeys = Object.keys(classPropsMetadata);
  var keys = stringKeys.concat(symbolKeys);
  for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
    var key = keys_1[_i];
    var targetMetadata = classPropsMetadata[key];
    var metadata = formatTargetMetadata(targetMetadata);
    var identifier = metadata.targetName || key;
    var serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName);
    var target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
    target.metadata = targetMetadata;
    targets.push(target);
  }
  var baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;
  if (baseConstructor !== Object) {
    var baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName);
    targets = __spreadArray(__spreadArray([], targets, true), baseTargets, true);
  }
  return targets;
}
function getBaseClassDependencyCount(metadataReader, func) {
  var baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
  if (baseConstructor !== Object) {
    var baseConstructorName = getFunctionName(baseConstructor);
    var targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);
    var metadata = targets.map(function(t3) {
      return t3.metadata.filter(function(m) {
        return m.key === UNMANAGED_TAG;
      });
    });
    var unmanagedCount = [].concat.apply([], metadata).length;
    var dependencyCount = targets.length - unmanagedCount;
    if (dependencyCount > 0) {
      return dependencyCount;
    } else {
      return getBaseClassDependencyCount(metadataReader, baseConstructor);
    }
  } else {
    return 0;
  }
}
function formatTargetMetadata(targetMetadata) {
  var targetMetadataMap = {};
  targetMetadata.forEach(function(m) {
    targetMetadataMap[m.key.toString()] = m.value;
  });
  return {
    inject: targetMetadataMap[INJECT_TAG],
    multiInject: targetMetadataMap[MULTI_INJECT_TAG],
    targetName: targetMetadataMap[NAME_TAG],
    unmanaged: targetMetadataMap[UNMANAGED_TAG]
  };
}

// node_modules/inversify/es/planning/request.js
var Request = function() {
  function Request2(serviceIdentifier, parentContext, parentRequest, bindings, target) {
    this.id = id();
    this.serviceIdentifier = serviceIdentifier;
    this.parentContext = parentContext;
    this.parentRequest = parentRequest;
    this.target = target;
    this.childRequests = [];
    this.bindings = Array.isArray(bindings) ? bindings : [bindings];
    this.requestScope = parentRequest === null ? /* @__PURE__ */ new Map() : null;
  }
  Request2.prototype.addChildRequest = function(serviceIdentifier, bindings, target) {
    var child = new Request2(serviceIdentifier, this.parentContext, this, bindings, target);
    this.childRequests.push(child);
    return child;
  };
  return Request2;
}();

// node_modules/inversify/es/planning/planner.js
function getBindingDictionary(cntnr) {
  return cntnr._bindingDictionary;
}
function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
  var metadataKey = isMultiInject ? MULTI_INJECT_TAG : INJECT_TAG;
  var injectMetadata = new Metadata(metadataKey, serviceIdentifier);
  var target = new Target(targetType, name, serviceIdentifier, injectMetadata);
  if (key !== void 0) {
    var tagMetadata = new Metadata(key, value);
    target.metadata.push(tagMetadata);
  }
  return target;
}
function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
  var bindings = getBindings(context.container, target.serviceIdentifier);
  var activeBindings = [];
  if (bindings.length === BindingCount.NoBindingsAvailable && context.container.options.autoBindInjectable && typeof target.serviceIdentifier === "function" && metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {
    context.container.bind(target.serviceIdentifier).toSelf();
    bindings = getBindings(context.container, target.serviceIdentifier);
  }
  if (!avoidConstraints) {
    activeBindings = bindings.filter(function(binding) {
      var request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);
      return binding.constraint(request);
    });
  } else {
    activeBindings = bindings;
  }
  _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
  return activeBindings;
}
function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
  switch (bindings.length) {
    case BindingCount.NoBindingsAvailable:
      if (target.isOptional()) {
        return bindings;
      } else {
        var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
        var msg = NOT_REGISTERED;
        msg += listMetadataForTarget(serviceIdentifierString, target);
        msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
        throw new Error(msg);
      }
    case BindingCount.OnlyOneBindingAvailable:
      return bindings;
    case BindingCount.MultipleBindingsAvailable:
    default:
      if (!target.isArray()) {
        var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
        var msg = AMBIGUOUS_MATCH + " " + serviceIdentifierString;
        msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
        throw new Error(msg);
      } else {
        return bindings;
      }
  }
}
function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
  var activeBindings;
  var childRequest;
  if (parentRequest === null) {
    activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
    childRequest = new Request(serviceIdentifier, context, null, activeBindings, target);
    var thePlan = new Plan(context, childRequest);
    context.addPlan(thePlan);
  } else {
    activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target);
    childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target);
  }
  activeBindings.forEach(function(binding) {
    var subChildRequest = null;
    if (target.isArray()) {
      subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
    } else {
      if (binding.cache) {
        return;
      }
      subChildRequest = childRequest;
    }
    if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) {
      var dependencies = getDependencies(metadataReader, binding.implementationType);
      if (!context.container.options.skipBaseClassChecks) {
        var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);
        if (dependencies.length < baseClassDependencyCount) {
          var error = ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));
          throw new Error(error);
        }
      }
      dependencies.forEach(function(dependency) {
        _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
      });
    }
  });
}
function getBindings(container, serviceIdentifier) {
  var bindings = [];
  var bindingDictionary = getBindingDictionary(container);
  if (bindingDictionary.hasKey(serviceIdentifier)) {
    bindings = bindingDictionary.get(serviceIdentifier);
  } else if (container.parent !== null) {
    bindings = getBindings(container.parent, serviceIdentifier);
  }
  return bindings;
}
function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints) {
  if (avoidConstraints === void 0) {
    avoidConstraints = false;
  }
  var context = new Context(container);
  var target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value);
  try {
    _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
    return context;
  } catch (error) {
    if (isStackOverflowExeption(error)) {
      circularDependencyToException(context.plan.rootRequest);
    }
    throw error;
  }
}
function createMockRequest(container, serviceIdentifier, key, value) {
  var target = new Target(TargetTypeEnum.Variable, "", serviceIdentifier, new Metadata(key, value));
  var context = new Context(container);
  var request = new Request(serviceIdentifier, context, null, [], target);
  return request;
}

// node_modules/inversify/es/utils/async.js
function isPromise(object) {
  var isObjectOrFunction = typeof object === "object" && object !== null || typeof object === "function";
  return isObjectOrFunction && typeof object.then === "function";
}
function isPromiseOrContainsPromise(object) {
  if (isPromise(object)) {
    return true;
  }
  return Array.isArray(object) && object.some(isPromise);
}

// node_modules/inversify/es/scope/scope.js
var __awaiter = function(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve2) {
      resolve2(value);
    });
  }
  return new (P || (P = Promise))(function(resolve2, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
var __generator = function(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t3[0] & 1)
      throw t3[1];
    return t3[1];
  }, trys: [], ops: [] }, f, y, t3, g;
  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
    return this;
  }), g;
  function verb(n) {
    return function(v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f)
      throw new TypeError("Generator is already executing.");
    while (_)
      try {
        if (f = 1, y && (t3 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t3 = y["return"]) && t3.call(y), 0) : y.next) && !(t3 = t3.call(y, op[1])).done)
          return t3;
        if (y = 0, t3)
          op = [op[0] & 2, t3.value];
        switch (op[0]) {
          case 0:
          case 1:
            t3 = op;
            break;
          case 4:
            _.label++;
            return { value: op[1], done: false };
          case 5:
            _.label++;
            y = op[1];
            op = [0];
            continue;
          case 7:
            op = _.ops.pop();
            _.trys.pop();
            continue;
          default:
            if (!(t3 = _.trys, t3 = t3.length > 0 && t3[t3.length - 1]) && (op[0] === 6 || op[0] === 2)) {
              _ = 0;
              continue;
            }
            if (op[0] === 3 && (!t3 || op[1] > t3[0] && op[1] < t3[3])) {
              _.label = op[1];
              break;
            }
            if (op[0] === 6 && _.label < t3[1]) {
              _.label = t3[1];
              t3 = op;
              break;
            }
            if (t3 && _.label < t3[2]) {
              _.label = t3[2];
              _.ops.push(op);
              break;
            }
            if (t3[2])
              _.ops.pop();
            _.trys.pop();
            continue;
        }
        op = body.call(thisArg, _);
      } catch (e) {
        op = [6, e];
        y = 0;
      } finally {
        f = t3 = 0;
      }
    if (op[0] & 5)
      throw op[1];
    return { value: op[0] ? op[1] : void 0, done: true };
  }
};
var tryGetFromScope = function(requestScope, binding) {
  if (binding.scope === BindingScopeEnum.Singleton && binding.activated) {
    return binding.cache;
  }
  if (binding.scope === BindingScopeEnum.Request && requestScope.has(binding.id)) {
    return requestScope.get(binding.id);
  }
  return null;
};
var saveToScope = function(requestScope, binding, result) {
  if (binding.scope === BindingScopeEnum.Singleton) {
    _saveToSingletonScope(binding, result);
  }
  if (binding.scope === BindingScopeEnum.Request) {
    _saveToRequestScope(requestScope, binding, result);
  }
};
var _saveToRequestScope = function(requestScope, binding, result) {
  if (!requestScope.has(binding.id)) {
    requestScope.set(binding.id, result);
  }
};
var _saveToSingletonScope = function(binding, result) {
  binding.cache = result;
  binding.activated = true;
  if (isPromise(result)) {
    void _saveAsyncResultToSingletonScope(binding, result);
  }
};
var _saveAsyncResultToSingletonScope = function(binding, asyncResult) {
  return __awaiter(void 0, void 0, void 0, function() {
    var result, ex_1;
    return __generator(this, function(_a) {
      switch (_a.label) {
        case 0:
          _a.trys.push([0, 2, , 3]);
          return [4, asyncResult];
        case 1:
          result = _a.sent();
          binding.cache = result;
          return [3, 3];
        case 2:
          ex_1 = _a.sent();
          binding.cache = null;
          binding.activated = false;
          throw ex_1;
        case 3:
          return [2];
      }
    });
  });
};

// node_modules/inversify/es/utils/factory_type.js
var FactoryType;
(function(FactoryType2) {
  FactoryType2["DynamicValue"] = "toDynamicValue";
  FactoryType2["Factory"] = "toFactory";
  FactoryType2["Provider"] = "toProvider";
})(FactoryType || (FactoryType = {}));

// node_modules/inversify/es/utils/binding_utils.js
var ensureFullyBound = function(binding) {
  var boundValue = null;
  switch (binding.type) {
    case BindingTypeEnum.ConstantValue:
    case BindingTypeEnum.Function:
      boundValue = binding.cache;
      break;
    case BindingTypeEnum.Constructor:
    case BindingTypeEnum.Instance:
      boundValue = binding.implementationType;
      break;
    case BindingTypeEnum.DynamicValue:
      boundValue = binding.dynamicValue;
      break;
    case BindingTypeEnum.Provider:
      boundValue = binding.provider;
      break;
    case BindingTypeEnum.Factory:
      boundValue = binding.factory;
      break;
  }
  if (boundValue === null) {
    var serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier);
    throw new Error(INVALID_BINDING_TYPE + " " + serviceIdentifierAsString);
  }
};
var getFactoryDetails = function(binding) {
  switch (binding.type) {
    case BindingTypeEnum.Factory:
      return { factory: binding.factory, factoryType: FactoryType.Factory };
    case BindingTypeEnum.Provider:
      return { factory: binding.provider, factoryType: FactoryType.Provider };
    case BindingTypeEnum.DynamicValue:
      return { factory: binding.dynamicValue, factoryType: FactoryType.DynamicValue };
    default:
      throw new Error("Unexpected factory type " + binding.type);
  }
};

// node_modules/inversify/es/resolution/instantiation.js
var __assign = function() {
  __assign = Object.assign || function(t3) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];
      for (var p in s)
        if (Object.prototype.hasOwnProperty.call(s, p))
          t3[p] = s[p];
    }
    return t3;
  };
  return __assign.apply(this, arguments);
};
var __awaiter2 = function(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve2) {
      resolve2(value);
    });
  }
  return new (P || (P = Promise))(function(resolve2, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
var __generator2 = function(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t3[0] & 1)
      throw t3[1];
    return t3[1];
  }, trys: [], ops: [] }, f, y, t3, g;
  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
    return this;
  }), g;
  function verb(n) {
    return function(v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f)
      throw new TypeError("Generator is already executing.");
    while (_)
      try {
        if (f = 1, y && (t3 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t3 = y["return"]) && t3.call(y), 0) : y.next) && !(t3 = t3.call(y, op[1])).done)
          return t3;
        if (y = 0, t3)
          op = [op[0] & 2, t3.value];
        switch (op[0]) {
          case 0:
          case 1:
            t3 = op;
            break;
          case 4:
            _.label++;
            return { value: op[1], done: false };
          case 5:
            _.label++;
            y = op[1];
            op = [0];
            continue;
          case 7:
            op = _.ops.pop();
            _.trys.pop();
            continue;
          default:
            if (!(t3 = _.trys, t3 = t3.length > 0 && t3[t3.length - 1]) && (op[0] === 6 || op[0] === 2)) {
              _ = 0;
              continue;
            }
            if (op[0] === 3 && (!t3 || op[1] > t3[0] && op[1] < t3[3])) {
              _.label = op[1];
              break;
            }
            if (op[0] === 6 && _.label < t3[1]) {
              _.label = t3[1];
              t3 = op;
              break;
            }
            if (t3 && _.label < t3[2]) {
              _.label = t3[2];
              _.ops.push(op);
              break;
            }
            if (t3[2])
              _.ops.pop();
            _.trys.pop();
            continue;
        }
        op = body.call(thisArg, _);
      } catch (e) {
        op = [6, e];
        y = 0;
      } finally {
        f = t3 = 0;
      }
    if (op[0] & 5)
      throw op[1];
    return { value: op[0] ? op[1] : void 0, done: true };
  }
};
var __spreadArray2 = function(to, from, pack) {
  if (pack || arguments.length === 2)
    for (var i = 0, l = from.length, ar; i < l; i++) {
      if (ar || !(i in from)) {
        if (!ar)
          ar = Array.prototype.slice.call(from, 0, i);
        ar[i] = from[i];
      }
    }
  return to.concat(ar || Array.prototype.slice.call(from));
};
function _resolveRequests(childRequests, resolveRequest) {
  return childRequests.reduce(function(resolvedRequests, childRequest) {
    var injection = resolveRequest(childRequest);
    var targetType = childRequest.target.type;
    if (targetType === TargetTypeEnum.ConstructorArgument) {
      resolvedRequests.constructorInjections.push(injection);
    } else {
      resolvedRequests.propertyRequests.push(childRequest);
      resolvedRequests.propertyInjections.push(injection);
    }
    if (!resolvedRequests.isAsync) {
      resolvedRequests.isAsync = isPromiseOrContainsPromise(injection);
    }
    return resolvedRequests;
  }, { constructorInjections: [], propertyInjections: [], propertyRequests: [], isAsync: false });
}
function _createInstance(constr, childRequests, resolveRequest) {
  var result;
  if (childRequests.length > 0) {
    var resolved2 = _resolveRequests(childRequests, resolveRequest);
    var createInstanceWithInjectionsArg = __assign(__assign({}, resolved2), { constr });
    if (resolved2.isAsync) {
      result = createInstanceWithInjectionsAsync(createInstanceWithInjectionsArg);
    } else {
      result = createInstanceWithInjections(createInstanceWithInjectionsArg);
    }
  } else {
    result = new constr();
  }
  return result;
}
function createInstanceWithInjections(args) {
  var _a;
  var instance2 = new ((_a = args.constr).bind.apply(_a, __spreadArray2([void 0], args.constructorInjections, false)))();
  args.propertyRequests.forEach(function(r, index) {
    var property = r.target.identifier;
    var injection = args.propertyInjections[index];
    instance2[property] = injection;
  });
  return instance2;
}
function createInstanceWithInjectionsAsync(args) {
  return __awaiter2(this, void 0, void 0, function() {
    var constructorInjections, propertyInjections;
    return __generator2(this, function(_a) {
      switch (_a.label) {
        case 0:
          return [4, possiblyWaitInjections(args.constructorInjections)];
        case 1:
          constructorInjections = _a.sent();
          return [4, possiblyWaitInjections(args.propertyInjections)];
        case 2:
          propertyInjections = _a.sent();
          return [2, createInstanceWithInjections(__assign(__assign({}, args), { constructorInjections, propertyInjections }))];
      }
    });
  });
}
function possiblyWaitInjections(possiblePromiseinjections) {
  return __awaiter2(this, void 0, void 0, function() {
    var injections, _i, possiblePromiseinjections_1, injection;
    return __generator2(this, function(_a) {
      injections = [];
      for (_i = 0, possiblePromiseinjections_1 = possiblePromiseinjections; _i < possiblePromiseinjections_1.length; _i++) {
        injection = possiblePromiseinjections_1[_i];
        if (Array.isArray(injection)) {
          injections.push(Promise.all(injection));
        } else {
          injections.push(injection);
        }
      }
      return [2, Promise.all(injections)];
    });
  });
}
function _getInstanceAfterPostConstruct(constr, result) {
  var postConstructResult = _postConstruct(constr, result);
  if (isPromise(postConstructResult)) {
    return postConstructResult.then(function() {
      return result;
    });
  } else {
    return result;
  }
}
function _postConstruct(constr, instance2) {
  var _a, _b;
  if (Reflect.hasMetadata(POST_CONSTRUCT, constr)) {
    var data = Reflect.getMetadata(POST_CONSTRUCT, constr);
    try {
      return (_b = (_a = instance2)[data.value]) === null || _b === void 0 ? void 0 : _b.call(_a);
    } catch (e) {
      throw new Error(POST_CONSTRUCT_ERROR(constr.name, e.message));
    }
  }
}
function _validateInstanceResolution(binding, constr) {
  if (binding.scope !== BindingScopeEnum.Singleton) {
    _throwIfHandlingDeactivation(binding, constr);
  }
}
function _throwIfHandlingDeactivation(binding, constr) {
  var scopeErrorMessage = "Class cannot be instantiated in " + (binding.scope === BindingScopeEnum.Request ? "request" : "transient") + " scope.";
  if (typeof binding.onDeactivation === "function") {
    throw new Error(ON_DEACTIVATION_ERROR(constr.name, scopeErrorMessage));
  }
  if (Reflect.hasMetadata(PRE_DESTROY, constr)) {
    throw new Error(PRE_DESTROY_ERROR(constr.name, scopeErrorMessage));
  }
}
function resolveInstance(binding, constr, childRequests, resolveRequest) {
  _validateInstanceResolution(binding, constr);
  var result = _createInstance(constr, childRequests, resolveRequest);
  if (isPromise(result)) {
    return result.then(function(resolvedResult) {
      return _getInstanceAfterPostConstruct(constr, resolvedResult);
    });
  } else {
    return _getInstanceAfterPostConstruct(constr, result);
  }
}

// node_modules/inversify/es/resolution/resolver.js
var __awaiter3 = function(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve2) {
      resolve2(value);
    });
  }
  return new (P || (P = Promise))(function(resolve2, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
var __generator3 = function(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t3[0] & 1)
      throw t3[1];
    return t3[1];
  }, trys: [], ops: [] }, f, y, t3, g;
  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
    return this;
  }), g;
  function verb(n) {
    return function(v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f)
      throw new TypeError("Generator is already executing.");
    while (_)
      try {
        if (f = 1, y && (t3 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t3 = y["return"]) && t3.call(y), 0) : y.next) && !(t3 = t3.call(y, op[1])).done)
          return t3;
        if (y = 0, t3)
          op = [op[0] & 2, t3.value];
        switch (op[0]) {
          case 0:
          case 1:
            t3 = op;
            break;
          case 4:
            _.label++;
            return { value: op[1], done: false };
          case 5:
            _.label++;
            y = op[1];
            op = [0];
            continue;
          case 7:
            op = _.ops.pop();
            _.trys.pop();
            continue;
          default:
            if (!(t3 = _.trys, t3 = t3.length > 0 && t3[t3.length - 1]) && (op[0] === 6 || op[0] === 2)) {
              _ = 0;
              continue;
            }
            if (op[0] === 3 && (!t3 || op[1] > t3[0] && op[1] < t3[3])) {
              _.label = op[1];
              break;
            }
            if (op[0] === 6 && _.label < t3[1]) {
              _.label = t3[1];
              t3 = op;
              break;
            }
            if (t3 && _.label < t3[2]) {
              _.label = t3[2];
              _.ops.push(op);
              break;
            }
            if (t3[2])
              _.ops.pop();
            _.trys.pop();
            continue;
        }
        op = body.call(thisArg, _);
      } catch (e) {
        op = [6, e];
        y = 0;
      } finally {
        f = t3 = 0;
      }
    if (op[0] & 5)
      throw op[1];
    return { value: op[0] ? op[1] : void 0, done: true };
  }
};
var _resolveRequest = function(requestScope) {
  return function(request) {
    request.parentContext.setCurrentRequest(request);
    var bindings = request.bindings;
    var childRequests = request.childRequests;
    var targetIsAnArray = request.target && request.target.isArray();
    var targetParentIsNotAnArray = !request.parentRequest || !request.parentRequest.target || !request.target || !request.parentRequest.target.matchesArray(request.target.serviceIdentifier);
    if (targetIsAnArray && targetParentIsNotAnArray) {
      return childRequests.map(function(childRequest) {
        var _f = _resolveRequest(requestScope);
        return _f(childRequest);
      });
    } else {
      if (request.target.isOptional() && bindings.length === 0) {
        return void 0;
      }
      var binding = bindings[0];
      return _resolveBinding(requestScope, request, binding);
    }
  };
};
var _resolveFactoryFromBinding = function(binding, context) {
  var factoryDetails = getFactoryDetails(binding);
  return tryAndThrowErrorIfStackOverflow(function() {
    return factoryDetails.factory.bind(binding)(context);
  }, function() {
    return new Error(CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString()));
  });
};
var _getResolvedFromBinding = function(requestScope, request, binding) {
  var result;
  var childRequests = request.childRequests;
  ensureFullyBound(binding);
  switch (binding.type) {
    case BindingTypeEnum.ConstantValue:
    case BindingTypeEnum.Function:
      result = binding.cache;
      break;
    case BindingTypeEnum.Constructor:
      result = binding.implementationType;
      break;
    case BindingTypeEnum.Instance:
      result = resolveInstance(binding, binding.implementationType, childRequests, _resolveRequest(requestScope));
      break;
    default:
      result = _resolveFactoryFromBinding(binding, request.parentContext);
  }
  return result;
};
var _resolveInScope = function(requestScope, binding, resolveFromBinding) {
  var result = tryGetFromScope(requestScope, binding);
  if (result !== null) {
    return result;
  }
  result = resolveFromBinding();
  saveToScope(requestScope, binding, result);
  return result;
};
var _resolveBinding = function(requestScope, request, binding) {
  return _resolveInScope(requestScope, binding, function() {
    var result = _getResolvedFromBinding(requestScope, request, binding);
    if (isPromise(result)) {
      result = result.then(function(resolved2) {
        return _onActivation(request, binding, resolved2);
      });
    } else {
      result = _onActivation(request, binding, result);
    }
    return result;
  });
};
function _onActivation(request, binding, resolved2) {
  var result = _bindingActivation(request.parentContext, binding, resolved2);
  var containersIterator = _getContainersIterator(request.parentContext.container);
  var container;
  var containersIteratorResult = containersIterator.next();
  do {
    container = containersIteratorResult.value;
    var context_1 = request.parentContext;
    var serviceIdentifier = request.serviceIdentifier;
    var activationsIterator = _getContainerActivationsForService(container, serviceIdentifier);
    if (isPromise(result)) {
      result = _activateContainerAsync(activationsIterator, context_1, result);
    } else {
      result = _activateContainer(activationsIterator, context_1, result);
    }
    containersIteratorResult = containersIterator.next();
  } while (containersIteratorResult.done !== true && !getBindingDictionary(container).hasKey(request.serviceIdentifier));
  return result;
}
var _bindingActivation = function(context, binding, previousResult) {
  var result;
  if (typeof binding.onActivation === "function") {
    result = binding.onActivation(context, previousResult);
  } else {
    result = previousResult;
  }
  return result;
};
var _activateContainer = function(activationsIterator, context, result) {
  var activation = activationsIterator.next();
  while (!activation.done) {
    result = activation.value(context, result);
    if (isPromise(result)) {
      return _activateContainerAsync(activationsIterator, context, result);
    }
    activation = activationsIterator.next();
  }
  return result;
};
var _activateContainerAsync = function(activationsIterator, context, resultPromise) {
  return __awaiter3(void 0, void 0, void 0, function() {
    var result, activation;
    return __generator3(this, function(_a) {
      switch (_a.label) {
        case 0:
          return [4, resultPromise];
        case 1:
          result = _a.sent();
          activation = activationsIterator.next();
          _a.label = 2;
        case 2:
          if (!!activation.done)
            return [3, 4];
          return [4, activation.value(context, result)];
        case 3:
          result = _a.sent();
          activation = activationsIterator.next();
          return [3, 2];
        case 4:
          return [2, result];
      }
    });
  });
};
var _getContainerActivationsForService = function(container, serviceIdentifier) {
  var activations = container._activations;
  return activations.hasKey(serviceIdentifier) ? activations.get(serviceIdentifier).values() : [].values();
};
var _getContainersIterator = function(container) {
  var containersStack = [container];
  var parent = container.parent;
  while (parent !== null) {
    containersStack.push(parent);
    parent = parent.parent;
  }
  var getNextContainer = function() {
    var nextContainer = containersStack.pop();
    if (nextContainer !== void 0) {
      return { done: false, value: nextContainer };
    } else {
      return { done: true, value: void 0 };
    }
  };
  var containersIterator = {
    next: getNextContainer
  };
  return containersIterator;
};
function resolve(context) {
  var _f = _resolveRequest(context.plan.rootRequest.requestScope);
  return _f(context.plan.rootRequest);
}

// node_modules/inversify/es/syntax/constraint_helpers.js
var traverseAncerstors = function(request, constraint) {
  var parent = request.parentRequest;
  if (parent !== null) {
    return constraint(parent) ? true : traverseAncerstors(parent, constraint);
  } else {
    return false;
  }
};
var taggedConstraint = function(key) {
  return function(value) {
    var constraint = function(request) {
      return request !== null && request.target !== null && request.target.matchesTag(key)(value);
    };
    constraint.metaData = new Metadata(key, value);
    return constraint;
  };
};
var namedConstraint = taggedConstraint(NAMED_TAG);
var typeConstraint = function(type) {
  return function(request) {
    var binding = null;
    if (request !== null) {
      binding = request.bindings[0];
      if (typeof type === "string") {
        var serviceIdentifier = binding.serviceIdentifier;
        return serviceIdentifier === type;
      } else {
        var constructor = request.bindings[0].implementationType;
        return type === constructor;
      }
    }
    return false;
  };
};

// node_modules/inversify/es/syntax/binding_when_syntax.js
var BindingWhenSyntax = function() {
  function BindingWhenSyntax2(binding) {
    this._binding = binding;
  }
  BindingWhenSyntax2.prototype.when = function(constraint) {
    this._binding.constraint = constraint;
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenTargetNamed = function(name) {
    this._binding.constraint = namedConstraint(name);
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenTargetIsDefault = function() {
    this._binding.constraint = function(request) {
      if (request === null) {
        return false;
      }
      var targetIsDefault = request.target !== null && !request.target.isNamed() && !request.target.isTagged();
      return targetIsDefault;
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenTargetTagged = function(tag, value) {
    this._binding.constraint = taggedConstraint(tag)(value);
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenInjectedInto = function(parent) {
    this._binding.constraint = function(request) {
      return request !== null && typeConstraint(parent)(request.parentRequest);
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenParentNamed = function(name) {
    this._binding.constraint = function(request) {
      return request !== null && namedConstraint(name)(request.parentRequest);
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenParentTagged = function(tag, value) {
    this._binding.constraint = function(request) {
      return request !== null && taggedConstraint(tag)(value)(request.parentRequest);
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenAnyAncestorIs = function(ancestor) {
    this._binding.constraint = function(request) {
      return request !== null && traverseAncerstors(request, typeConstraint(ancestor));
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenNoAncestorIs = function(ancestor) {
    this._binding.constraint = function(request) {
      return request !== null && !traverseAncerstors(request, typeConstraint(ancestor));
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenAnyAncestorNamed = function(name) {
    this._binding.constraint = function(request) {
      return request !== null && traverseAncerstors(request, namedConstraint(name));
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenNoAncestorNamed = function(name) {
    this._binding.constraint = function(request) {
      return request !== null && !traverseAncerstors(request, namedConstraint(name));
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenAnyAncestorTagged = function(tag, value) {
    this._binding.constraint = function(request) {
      return request !== null && traverseAncerstors(request, taggedConstraint(tag)(value));
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenNoAncestorTagged = function(tag, value) {
    this._binding.constraint = function(request) {
      return request !== null && !traverseAncerstors(request, taggedConstraint(tag)(value));
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenAnyAncestorMatches = function(constraint) {
    this._binding.constraint = function(request) {
      return request !== null && traverseAncerstors(request, constraint);
    };
    return new BindingOnSyntax(this._binding);
  };
  BindingWhenSyntax2.prototype.whenNoAncestorMatches = function(constraint) {
    this._binding.constraint = function(request) {
      return request !== null && !traverseAncerstors(request, constraint);
    };
    return new BindingOnSyntax(this._binding);
  };
  return BindingWhenSyntax2;
}();

// node_modules/inversify/es/syntax/binding_on_syntax.js
var BindingOnSyntax = function() {
  function BindingOnSyntax2(binding) {
    this._binding = binding;
  }
  BindingOnSyntax2.prototype.onActivation = function(handler) {
    this._binding.onActivation = handler;
    return new BindingWhenSyntax(this._binding);
  };
  BindingOnSyntax2.prototype.onDeactivation = function(handler) {
    this._binding.onDeactivation = handler;
    return new BindingWhenSyntax(this._binding);
  };
  return BindingOnSyntax2;
}();

// node_modules/inversify/es/syntax/binding_when_on_syntax.js
var BindingWhenOnSyntax = function() {
  function BindingWhenOnSyntax2(binding) {
    this._binding = binding;
    this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
    this._bindingOnSyntax = new BindingOnSyntax(this._binding);
  }
  BindingWhenOnSyntax2.prototype.when = function(constraint) {
    return this._bindingWhenSyntax.when(constraint);
  };
  BindingWhenOnSyntax2.prototype.whenTargetNamed = function(name) {
    return this._bindingWhenSyntax.whenTargetNamed(name);
  };
  BindingWhenOnSyntax2.prototype.whenTargetIsDefault = function() {
    return this._bindingWhenSyntax.whenTargetIsDefault();
  };
  BindingWhenOnSyntax2.prototype.whenTargetTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenTargetTagged(tag, value);
  };
  BindingWhenOnSyntax2.prototype.whenInjectedInto = function(parent) {
    return this._bindingWhenSyntax.whenInjectedInto(parent);
  };
  BindingWhenOnSyntax2.prototype.whenParentNamed = function(name) {
    return this._bindingWhenSyntax.whenParentNamed(name);
  };
  BindingWhenOnSyntax2.prototype.whenParentTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenParentTagged(tag, value);
  };
  BindingWhenOnSyntax2.prototype.whenAnyAncestorIs = function(ancestor) {
    return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
  };
  BindingWhenOnSyntax2.prototype.whenNoAncestorIs = function(ancestor) {
    return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
  };
  BindingWhenOnSyntax2.prototype.whenAnyAncestorNamed = function(name) {
    return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
  };
  BindingWhenOnSyntax2.prototype.whenAnyAncestorTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
  };
  BindingWhenOnSyntax2.prototype.whenNoAncestorNamed = function(name) {
    return this._bindingWhenSyntax.whenNoAncestorNamed(name);
  };
  BindingWhenOnSyntax2.prototype.whenNoAncestorTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
  };
  BindingWhenOnSyntax2.prototype.whenAnyAncestorMatches = function(constraint) {
    return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
  };
  BindingWhenOnSyntax2.prototype.whenNoAncestorMatches = function(constraint) {
    return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
  };
  BindingWhenOnSyntax2.prototype.onActivation = function(handler) {
    return this._bindingOnSyntax.onActivation(handler);
  };
  BindingWhenOnSyntax2.prototype.onDeactivation = function(handler) {
    return this._bindingOnSyntax.onDeactivation(handler);
  };
  return BindingWhenOnSyntax2;
}();

// node_modules/inversify/es/syntax/binding_in_syntax.js
var BindingInSyntax = function() {
  function BindingInSyntax2(binding) {
    this._binding = binding;
  }
  BindingInSyntax2.prototype.inRequestScope = function() {
    this._binding.scope = BindingScopeEnum.Request;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingInSyntax2.prototype.inSingletonScope = function() {
    this._binding.scope = BindingScopeEnum.Singleton;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingInSyntax2.prototype.inTransientScope = function() {
    this._binding.scope = BindingScopeEnum.Transient;
    return new BindingWhenOnSyntax(this._binding);
  };
  return BindingInSyntax2;
}();

// node_modules/inversify/es/syntax/binding_in_when_on_syntax.js
var BindingInWhenOnSyntax = function() {
  function BindingInWhenOnSyntax2(binding) {
    this._binding = binding;
    this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
    this._bindingOnSyntax = new BindingOnSyntax(this._binding);
    this._bindingInSyntax = new BindingInSyntax(binding);
  }
  BindingInWhenOnSyntax2.prototype.inRequestScope = function() {
    return this._bindingInSyntax.inRequestScope();
  };
  BindingInWhenOnSyntax2.prototype.inSingletonScope = function() {
    return this._bindingInSyntax.inSingletonScope();
  };
  BindingInWhenOnSyntax2.prototype.inTransientScope = function() {
    return this._bindingInSyntax.inTransientScope();
  };
  BindingInWhenOnSyntax2.prototype.when = function(constraint) {
    return this._bindingWhenSyntax.when(constraint);
  };
  BindingInWhenOnSyntax2.prototype.whenTargetNamed = function(name) {
    return this._bindingWhenSyntax.whenTargetNamed(name);
  };
  BindingInWhenOnSyntax2.prototype.whenTargetIsDefault = function() {
    return this._bindingWhenSyntax.whenTargetIsDefault();
  };
  BindingInWhenOnSyntax2.prototype.whenTargetTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenTargetTagged(tag, value);
  };
  BindingInWhenOnSyntax2.prototype.whenInjectedInto = function(parent) {
    return this._bindingWhenSyntax.whenInjectedInto(parent);
  };
  BindingInWhenOnSyntax2.prototype.whenParentNamed = function(name) {
    return this._bindingWhenSyntax.whenParentNamed(name);
  };
  BindingInWhenOnSyntax2.prototype.whenParentTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenParentTagged(tag, value);
  };
  BindingInWhenOnSyntax2.prototype.whenAnyAncestorIs = function(ancestor) {
    return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
  };
  BindingInWhenOnSyntax2.prototype.whenNoAncestorIs = function(ancestor) {
    return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
  };
  BindingInWhenOnSyntax2.prototype.whenAnyAncestorNamed = function(name) {
    return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
  };
  BindingInWhenOnSyntax2.prototype.whenAnyAncestorTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
  };
  BindingInWhenOnSyntax2.prototype.whenNoAncestorNamed = function(name) {
    return this._bindingWhenSyntax.whenNoAncestorNamed(name);
  };
  BindingInWhenOnSyntax2.prototype.whenNoAncestorTagged = function(tag, value) {
    return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
  };
  BindingInWhenOnSyntax2.prototype.whenAnyAncestorMatches = function(constraint) {
    return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
  };
  BindingInWhenOnSyntax2.prototype.whenNoAncestorMatches = function(constraint) {
    return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
  };
  BindingInWhenOnSyntax2.prototype.onActivation = function(handler) {
    return this._bindingOnSyntax.onActivation(handler);
  };
  BindingInWhenOnSyntax2.prototype.onDeactivation = function(handler) {
    return this._bindingOnSyntax.onDeactivation(handler);
  };
  return BindingInWhenOnSyntax2;
}();

// node_modules/inversify/es/syntax/binding_to_syntax.js
var BindingToSyntax = function() {
  function BindingToSyntax2(binding) {
    this._binding = binding;
  }
  BindingToSyntax2.prototype.to = function(constructor) {
    this._binding.type = BindingTypeEnum.Instance;
    this._binding.implementationType = constructor;
    return new BindingInWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toSelf = function() {
    if (typeof this._binding.serviceIdentifier !== "function") {
      throw new Error("" + INVALID_TO_SELF_VALUE);
    }
    var self2 = this._binding.serviceIdentifier;
    return this.to(self2);
  };
  BindingToSyntax2.prototype.toConstantValue = function(value) {
    this._binding.type = BindingTypeEnum.ConstantValue;
    this._binding.cache = value;
    this._binding.dynamicValue = null;
    this._binding.implementationType = null;
    this._binding.scope = BindingScopeEnum.Singleton;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toDynamicValue = function(func) {
    this._binding.type = BindingTypeEnum.DynamicValue;
    this._binding.cache = null;
    this._binding.dynamicValue = func;
    this._binding.implementationType = null;
    return new BindingInWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toConstructor = function(constructor) {
    this._binding.type = BindingTypeEnum.Constructor;
    this._binding.implementationType = constructor;
    this._binding.scope = BindingScopeEnum.Singleton;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toFactory = function(factory) {
    this._binding.type = BindingTypeEnum.Factory;
    this._binding.factory = factory;
    this._binding.scope = BindingScopeEnum.Singleton;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toFunction = function(func) {
    if (typeof func !== "function") {
      throw new Error(INVALID_FUNCTION_BINDING);
    }
    var bindingWhenOnSyntax = this.toConstantValue(func);
    this._binding.type = BindingTypeEnum.Function;
    this._binding.scope = BindingScopeEnum.Singleton;
    return bindingWhenOnSyntax;
  };
  BindingToSyntax2.prototype.toAutoFactory = function(serviceIdentifier) {
    this._binding.type = BindingTypeEnum.Factory;
    this._binding.factory = function(context) {
      var autofactory = function() {
        return context.container.get(serviceIdentifier);
      };
      return autofactory;
    };
    this._binding.scope = BindingScopeEnum.Singleton;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toAutoNamedFactory = function(serviceIdentifier) {
    this._binding.type = BindingTypeEnum.Factory;
    this._binding.factory = function(context) {
      return function(named2) {
        return context.container.getNamed(serviceIdentifier, named2);
      };
    };
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toProvider = function(provider) {
    this._binding.type = BindingTypeEnum.Provider;
    this._binding.provider = provider;
    this._binding.scope = BindingScopeEnum.Singleton;
    return new BindingWhenOnSyntax(this._binding);
  };
  BindingToSyntax2.prototype.toService = function(service) {
    this.toDynamicValue(function(context) {
      return context.container.get(service);
    });
  };
  return BindingToSyntax2;
}();

// node_modules/inversify/es/container/container_snapshot.js
var ContainerSnapshot = function() {
  function ContainerSnapshot2() {
  }
  ContainerSnapshot2.of = function(bindings, middleware, activations, deactivations, moduleActivationStore) {
    var snapshot = new ContainerSnapshot2();
    snapshot.bindings = bindings;
    snapshot.middleware = middleware;
    snapshot.deactivations = deactivations;
    snapshot.activations = activations;
    snapshot.moduleActivationStore = moduleActivationStore;
    return snapshot;
  };
  return ContainerSnapshot2;
}();

// node_modules/inversify/es/utils/clonable.js
function isClonable(obj) {
  return typeof obj === "object" && obj !== null && "clone" in obj && typeof obj.clone === "function";
}

// node_modules/inversify/es/container/lookup.js
var Lookup = function() {
  function Lookup2() {
    this._map = /* @__PURE__ */ new Map();
  }
  Lookup2.prototype.getMap = function() {
    return this._map;
  };
  Lookup2.prototype.add = function(serviceIdentifier, value) {
    if (serviceIdentifier === null || serviceIdentifier === void 0) {
      throw new Error(NULL_ARGUMENT);
    }
    if (value === null || value === void 0) {
      throw new Error(NULL_ARGUMENT);
    }
    var entry = this._map.get(serviceIdentifier);
    if (entry !== void 0) {
      entry.push(value);
    } else {
      this._map.set(serviceIdentifier, [value]);
    }
  };
  Lookup2.prototype.get = function(serviceIdentifier) {
    if (serviceIdentifier === null || serviceIdentifier === void 0) {
      throw new Error(NULL_ARGUMENT);
    }
    var entry = this._map.get(serviceIdentifier);
    if (entry !== void 0) {
      return entry;
    } else {
      throw new Error(KEY_NOT_FOUND);
    }
  };
  Lookup2.prototype.remove = function(serviceIdentifier) {
    if (serviceIdentifier === null || serviceIdentifier === void 0) {
      throw new Error(NULL_ARGUMENT);
    }
    if (!this._map.delete(serviceIdentifier)) {
      throw new Error(KEY_NOT_FOUND);
    }
  };
  Lookup2.prototype.removeIntersection = function(lookup) {
    var _this = this;
    this.traverse(function(serviceIdentifier, value) {
      var lookupActivations = lookup.hasKey(serviceIdentifier) ? lookup.get(serviceIdentifier) : void 0;
      if (lookupActivations !== void 0) {
        var filteredValues = value.filter(function(lookupValue) {
          return !lookupActivations.some(function(moduleActivation) {
            return lookupValue === moduleActivation;
          });
        });
        _this._setValue(serviceIdentifier, filteredValues);
      }
    });
  };
  Lookup2.prototype.removeByCondition = function(condition) {
    var _this = this;
    var removals = [];
    this._map.forEach(function(entries, key) {
      var updatedEntries = [];
      for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
        var entry = entries_1[_i];
        var remove = condition(entry);
        if (remove) {
          removals.push(entry);
        } else {
          updatedEntries.push(entry);
        }
      }
      _this._setValue(key, updatedEntries);
    });
    return removals;
  };
  Lookup2.prototype.hasKey = function(serviceIdentifier) {
    if (serviceIdentifier === null || serviceIdentifier === void 0) {
      throw new Error(NULL_ARGUMENT);
    }
    return this._map.has(serviceIdentifier);
  };
  Lookup2.prototype.clone = function() {
    var copy2 = new Lookup2();
    this._map.forEach(function(value, key) {
      value.forEach(function(b) {
        return copy2.add(key, isClonable(b) ? b.clone() : b);
      });
    });
    return copy2;
  };
  Lookup2.prototype.traverse = function(func) {
    this._map.forEach(function(value, key) {
      func(key, value);
    });
  };
  Lookup2.prototype._setValue = function(serviceIdentifier, value) {
    if (value.length > 0) {
      this._map.set(serviceIdentifier, value);
    } else {
      this._map.delete(serviceIdentifier);
    }
  };
  return Lookup2;
}();

// node_modules/inversify/es/container/module_activation_store.js
var ModuleActivationStore = function() {
  function ModuleActivationStore2() {
    this._map = /* @__PURE__ */ new Map();
  }
  ModuleActivationStore2.prototype.remove = function(moduleId) {
    if (this._map.has(moduleId)) {
      var handlers = this._map.get(moduleId);
      this._map.delete(moduleId);
      return handlers;
    }
    return this._getEmptyHandlersStore();
  };
  ModuleActivationStore2.prototype.addDeactivation = function(moduleId, serviceIdentifier, onDeactivation) {
    this._getModuleActivationHandlers(moduleId).onDeactivations.add(serviceIdentifier, onDeactivation);
  };
  ModuleActivationStore2.prototype.addActivation = function(moduleId, serviceIdentifier, onActivation) {
    this._getModuleActivationHandlers(moduleId).onActivations.add(serviceIdentifier, onActivation);
  };
  ModuleActivationStore2.prototype.clone = function() {
    var clone = new ModuleActivationStore2();
    this._map.forEach(function(handlersStore, moduleId) {
      clone._map.set(moduleId, {
        onActivations: handlersStore.onActivations.clone(),
        onDeactivations: handlersStore.onDeactivations.clone()
      });
    });
    return clone;
  };
  ModuleActivationStore2.prototype._getModuleActivationHandlers = function(moduleId) {
    var moduleActivationHandlers = this._map.get(moduleId);
    if (moduleActivationHandlers === void 0) {
      moduleActivationHandlers = this._getEmptyHandlersStore();
      this._map.set(moduleId, moduleActivationHandlers);
    }
    return moduleActivationHandlers;
  };
  ModuleActivationStore2.prototype._getEmptyHandlersStore = function() {
    var handlersStore = {
      onActivations: new Lookup(),
      onDeactivations: new Lookup()
    };
    return handlersStore;
  };
  return ModuleActivationStore2;
}();

// node_modules/inversify/es/container/container.js
var __assign2 = function() {
  __assign2 = Object.assign || function(t3) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];
      for (var p in s)
        if (Object.prototype.hasOwnProperty.call(s, p))
          t3[p] = s[p];
    }
    return t3;
  };
  return __assign2.apply(this, arguments);
};
var __awaiter4 = function(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve2) {
      resolve2(value);
    });
  }
  return new (P || (P = Promise))(function(resolve2, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
var __generator4 = function(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t3[0] & 1)
      throw t3[1];
    return t3[1];
  }, trys: [], ops: [] }, f, y, t3, g;
  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
    return this;
  }), g;
  function verb(n) {
    return function(v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f)
      throw new TypeError("Generator is already executing.");
    while (_)
      try {
        if (f = 1, y && (t3 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t3 = y["return"]) && t3.call(y), 0) : y.next) && !(t3 = t3.call(y, op[1])).done)
          return t3;
        if (y = 0, t3)
          op = [op[0] & 2, t3.value];
        switch (op[0]) {
          case 0:
          case 1:
            t3 = op;
            break;
          case 4:
            _.label++;
            return { value: op[1], done: false };
          case 5:
            _.label++;
            y = op[1];
            op = [0];
            continue;
          case 7:
            op = _.ops.pop();
            _.trys.pop();
            continue;
          default:
            if (!(t3 = _.trys, t3 = t3.length > 0 && t3[t3.length - 1]) && (op[0] === 6 || op[0] === 2)) {
              _ = 0;
              continue;
            }
            if (op[0] === 3 && (!t3 || op[1] > t3[0] && op[1] < t3[3])) {
              _.label = op[1];
              break;
            }
            if (op[0] === 6 && _.label < t3[1]) {
              _.label = t3[1];
              t3 = op;
              break;
            }
            if (t3 && _.label < t3[2]) {
              _.label = t3[2];
              _.ops.push(op);
              break;
            }
            if (t3[2])
              _.ops.pop();
            _.trys.pop();
            continue;
        }
        op = body.call(thisArg, _);
      } catch (e) {
        op = [6, e];
        y = 0;
      } finally {
        f = t3 = 0;
      }
    if (op[0] & 5)
      throw op[1];
    return { value: op[0] ? op[1] : void 0, done: true };
  }
};
var __spreadArray3 = function(to, from, pack) {
  if (pack || arguments.length === 2)
    for (var i = 0, l = from.length, ar; i < l; i++) {
      if (ar || !(i in from)) {
        if (!ar)
          ar = Array.prototype.slice.call(from, 0, i);
        ar[i] = from[i];
      }
    }
  return to.concat(ar || Array.prototype.slice.call(from));
};
var Container = function() {
  function Container3(containerOptions) {
    var options = containerOptions || {};
    if (typeof options !== "object") {
      throw new Error("" + CONTAINER_OPTIONS_MUST_BE_AN_OBJECT);
    }
    if (options.defaultScope === void 0) {
      options.defaultScope = BindingScopeEnum.Transient;
    } else if (options.defaultScope !== BindingScopeEnum.Singleton && options.defaultScope !== BindingScopeEnum.Transient && options.defaultScope !== BindingScopeEnum.Request) {
      throw new Error("" + CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE);
    }
    if (options.autoBindInjectable === void 0) {
      options.autoBindInjectable = false;
    } else if (typeof options.autoBindInjectable !== "boolean") {
      throw new Error("" + CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE);
    }
    if (options.skipBaseClassChecks === void 0) {
      options.skipBaseClassChecks = false;
    } else if (typeof options.skipBaseClassChecks !== "boolean") {
      throw new Error("" + CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK);
    }
    this.options = {
      autoBindInjectable: options.autoBindInjectable,
      defaultScope: options.defaultScope,
      skipBaseClassChecks: options.skipBaseClassChecks
    };
    this.id = id();
    this._bindingDictionary = new Lookup();
    this._snapshots = [];
    this._middleware = null;
    this._activations = new Lookup();
    this._deactivations = new Lookup();
    this.parent = null;
    this._metadataReader = new MetadataReader();
    this._moduleActivationStore = new ModuleActivationStore();
  }
  Container3.merge = function(container1, container2) {
    var containers = [];
    for (var _i = 2; _i < arguments.length; _i++) {
      containers[_i - 2] = arguments[_i];
    }
    var container = new Container3();
    var targetContainers = __spreadArray3([container1, container2], containers, true).map(function(targetContainer) {
      return getBindingDictionary(targetContainer);
    });
    var bindingDictionary = getBindingDictionary(container);
    function copyDictionary(origin, destination) {
      origin.traverse(function(_key, value) {
        value.forEach(function(binding) {
          destination.add(binding.serviceIdentifier, binding.clone());
        });
      });
    }
    targetContainers.forEach(function(targetBindingDictionary) {
      copyDictionary(targetBindingDictionary, bindingDictionary);
    });
    return container;
  };
  Container3.prototype.load = function() {
    var modules = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      modules[_i] = arguments[_i];
    }
    var getHelpers = this._getContainerModuleHelpersFactory();
    for (var _a = 0, modules_1 = modules; _a < modules_1.length; _a++) {
      var currentModule = modules_1[_a];
      var containerModuleHelpers = getHelpers(currentModule.id);
      currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction, containerModuleHelpers.unbindAsyncFunction, containerModuleHelpers.onActivationFunction, containerModuleHelpers.onDeactivationFunction);
    }
  };
  Container3.prototype.loadAsync = function() {
    var modules = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      modules[_i] = arguments[_i];
    }
    return __awaiter4(this, void 0, void 0, function() {
      var getHelpers, _a, modules_2, currentModule, containerModuleHelpers;
      return __generator4(this, function(_b) {
        switch (_b.label) {
          case 0:
            getHelpers = this._getContainerModuleHelpersFactory();
            _a = 0, modules_2 = modules;
            _b.label = 1;
          case 1:
            if (!(_a < modules_2.length))
              return [3, 4];
            currentModule = modules_2[_a];
            containerModuleHelpers = getHelpers(currentModule.id);
            return [4, currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction, containerModuleHelpers.unbindAsyncFunction, containerModuleHelpers.onActivationFunction, containerModuleHelpers.onDeactivationFunction)];
          case 2:
            _b.sent();
            _b.label = 3;
          case 3:
            _a++;
            return [3, 1];
          case 4:
            return [2];
        }
      });
    });
  };
  Container3.prototype.unload = function() {
    var _this = this;
    var modules = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      modules[_i] = arguments[_i];
    }
    modules.forEach(function(module2) {
      var deactivations = _this._removeModuleBindings(module2.id);
      _this._deactivateSingletons(deactivations);
      _this._removeModuleHandlers(module2.id);
    });
  };
  Container3.prototype.unloadAsync = function() {
    var modules = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      modules[_i] = arguments[_i];
    }
    return __awaiter4(this, void 0, void 0, function() {
      var _a, modules_3, module_1, deactivations;
      return __generator4(this, function(_b) {
        switch (_b.label) {
          case 0:
            _a = 0, modules_3 = modules;
            _b.label = 1;
          case 1:
            if (!(_a < modules_3.length))
              return [3, 4];
            module_1 = modules_3[_a];
            deactivations = this._removeModuleBindings(module_1.id);
            return [4, this._deactivateSingletonsAsync(deactivations)];
          case 2:
            _b.sent();
            this._removeModuleHandlers(module_1.id);
            _b.label = 3;
          case 3:
            _a++;
            return [3, 1];
          case 4:
            return [2];
        }
      });
    });
  };
  Container3.prototype.bind = function(serviceIdentifier) {
    var scope = this.options.defaultScope || BindingScopeEnum.Transient;
    var binding = new Binding(serviceIdentifier, scope);
    this._bindingDictionary.add(serviceIdentifier, binding);
    return new BindingToSyntax(binding);
  };
  Container3.prototype.rebind = function(serviceIdentifier) {
    this.unbind(serviceIdentifier);
    return this.bind(serviceIdentifier);
  };
  Container3.prototype.rebindAsync = function(serviceIdentifier) {
    return __awaiter4(this, void 0, void 0, function() {
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            return [4, this.unbindAsync(serviceIdentifier)];
          case 1:
            _a.sent();
            return [2, this.bind(serviceIdentifier)];
        }
      });
    });
  };
  Container3.prototype.unbind = function(serviceIdentifier) {
    if (this._bindingDictionary.hasKey(serviceIdentifier)) {
      var bindings = this._bindingDictionary.get(serviceIdentifier);
      this._deactivateSingletons(bindings);
    }
    this._removeServiceFromDictionary(serviceIdentifier);
  };
  Container3.prototype.unbindAsync = function(serviceIdentifier) {
    return __awaiter4(this, void 0, void 0, function() {
      var bindings;
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            if (!this._bindingDictionary.hasKey(serviceIdentifier))
              return [3, 2];
            bindings = this._bindingDictionary.get(serviceIdentifier);
            return [4, this._deactivateSingletonsAsync(bindings)];
          case 1:
            _a.sent();
            _a.label = 2;
          case 2:
            this._removeServiceFromDictionary(serviceIdentifier);
            return [2];
        }
      });
    });
  };
  Container3.prototype.unbindAll = function() {
    var _this = this;
    this._bindingDictionary.traverse(function(_key, value) {
      _this._deactivateSingletons(value);
    });
    this._bindingDictionary = new Lookup();
  };
  Container3.prototype.unbindAllAsync = function() {
    return __awaiter4(this, void 0, void 0, function() {
      var promises;
      var _this = this;
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            promises = [];
            this._bindingDictionary.traverse(function(_key, value) {
              promises.push(_this._deactivateSingletonsAsync(value));
            });
            return [4, Promise.all(promises)];
          case 1:
            _a.sent();
            this._bindingDictionary = new Lookup();
            return [2];
        }
      });
    });
  };
  Container3.prototype.onActivation = function(serviceIdentifier, onActivation) {
    this._activations.add(serviceIdentifier, onActivation);
  };
  Container3.prototype.onDeactivation = function(serviceIdentifier, onDeactivation) {
    this._deactivations.add(serviceIdentifier, onDeactivation);
  };
  Container3.prototype.isBound = function(serviceIdentifier) {
    var bound = this._bindingDictionary.hasKey(serviceIdentifier);
    if (!bound && this.parent) {
      bound = this.parent.isBound(serviceIdentifier);
    }
    return bound;
  };
  Container3.prototype.isCurrentBound = function(serviceIdentifier) {
    return this._bindingDictionary.hasKey(serviceIdentifier);
  };
  Container3.prototype.isBoundNamed = function(serviceIdentifier, named2) {
    return this.isBoundTagged(serviceIdentifier, NAMED_TAG, named2);
  };
  Container3.prototype.isBoundTagged = function(serviceIdentifier, key, value) {
    var bound = false;
    if (this._bindingDictionary.hasKey(serviceIdentifier)) {
      var bindings = this._bindingDictionary.get(serviceIdentifier);
      var request_1 = createMockRequest(this, serviceIdentifier, key, value);
      bound = bindings.some(function(b) {
        return b.constraint(request_1);
      });
    }
    if (!bound && this.parent) {
      bound = this.parent.isBoundTagged(serviceIdentifier, key, value);
    }
    return bound;
  };
  Container3.prototype.snapshot = function() {
    this._snapshots.push(ContainerSnapshot.of(this._bindingDictionary.clone(), this._middleware, this._activations.clone(), this._deactivations.clone(), this._moduleActivationStore.clone()));
  };
  Container3.prototype.restore = function() {
    var snapshot = this._snapshots.pop();
    if (snapshot === void 0) {
      throw new Error(NO_MORE_SNAPSHOTS_AVAILABLE);
    }
    this._bindingDictionary = snapshot.bindings;
    this._activations = snapshot.activations;
    this._deactivations = snapshot.deactivations;
    this._middleware = snapshot.middleware;
    this._moduleActivationStore = snapshot.moduleActivationStore;
  };
  Container3.prototype.createChild = function(containerOptions) {
    var child = new Container3(containerOptions || this.options);
    child.parent = this;
    return child;
  };
  Container3.prototype.applyMiddleware = function() {
    var middlewares = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      middlewares[_i] = arguments[_i];
    }
    var initial = this._middleware ? this._middleware : this._planAndResolve();
    this._middleware = middlewares.reduce(function(prev, curr) {
      return curr(prev);
    }, initial);
  };
  Container3.prototype.applyCustomMetadataReader = function(metadataReader) {
    this._metadataReader = metadataReader;
  };
  Container3.prototype.get = function(serviceIdentifier) {
    var getArgs = this._getNotAllArgs(serviceIdentifier, false);
    return this._getButThrowIfAsync(getArgs);
  };
  Container3.prototype.getAsync = function(serviceIdentifier) {
    return __awaiter4(this, void 0, void 0, function() {
      var getArgs;
      return __generator4(this, function(_a) {
        getArgs = this._getNotAllArgs(serviceIdentifier, false);
        return [2, this._get(getArgs)];
      });
    });
  };
  Container3.prototype.getTagged = function(serviceIdentifier, key, value) {
    var getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);
    return this._getButThrowIfAsync(getArgs);
  };
  Container3.prototype.getTaggedAsync = function(serviceIdentifier, key, value) {
    return __awaiter4(this, void 0, void 0, function() {
      var getArgs;
      return __generator4(this, function(_a) {
        getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);
        return [2, this._get(getArgs)];
      });
    });
  };
  Container3.prototype.getNamed = function(serviceIdentifier, named2) {
    return this.getTagged(serviceIdentifier, NAMED_TAG, named2);
  };
  Container3.prototype.getNamedAsync = function(serviceIdentifier, named2) {
    return this.getTaggedAsync(serviceIdentifier, NAMED_TAG, named2);
  };
  Container3.prototype.getAll = function(serviceIdentifier) {
    var getArgs = this._getAllArgs(serviceIdentifier);
    return this._getButThrowIfAsync(getArgs);
  };
  Container3.prototype.getAllAsync = function(serviceIdentifier) {
    var getArgs = this._getAllArgs(serviceIdentifier);
    return this._getAll(getArgs);
  };
  Container3.prototype.getAllTagged = function(serviceIdentifier, key, value) {
    var getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value);
    return this._getButThrowIfAsync(getArgs);
  };
  Container3.prototype.getAllTaggedAsync = function(serviceIdentifier, key, value) {
    var getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value);
    return this._getAll(getArgs);
  };
  Container3.prototype.getAllNamed = function(serviceIdentifier, named2) {
    return this.getAllTagged(serviceIdentifier, NAMED_TAG, named2);
  };
  Container3.prototype.getAllNamedAsync = function(serviceIdentifier, named2) {
    return this.getAllTaggedAsync(serviceIdentifier, NAMED_TAG, named2);
  };
  Container3.prototype.resolve = function(constructorFunction) {
    var isBound = this.isBound(constructorFunction);
    if (!isBound) {
      this.bind(constructorFunction).toSelf();
    }
    var resolved2 = this.get(constructorFunction);
    if (!isBound) {
      this.unbind(constructorFunction);
    }
    return resolved2;
  };
  Container3.prototype._preDestroy = function(constructor, instance2) {
    if (Reflect.hasMetadata(PRE_DESTROY, constructor)) {
      var data = Reflect.getMetadata(PRE_DESTROY, constructor);
      return instance2[data.value]();
    }
  };
  Container3.prototype._removeModuleHandlers = function(moduleId) {
    var moduleActivationsHandlers = this._moduleActivationStore.remove(moduleId);
    this._activations.removeIntersection(moduleActivationsHandlers.onActivations);
    this._deactivations.removeIntersection(moduleActivationsHandlers.onDeactivations);
  };
  Container3.prototype._removeModuleBindings = function(moduleId) {
    return this._bindingDictionary.removeByCondition(function(binding) {
      return binding.moduleId === moduleId;
    });
  };
  Container3.prototype._deactivate = function(binding, instance2) {
    var _this = this;
    var constructor = Object.getPrototypeOf(instance2).constructor;
    try {
      if (this._deactivations.hasKey(binding.serviceIdentifier)) {
        var result = this._deactivateContainer(instance2, this._deactivations.get(binding.serviceIdentifier).values());
        if (isPromise(result)) {
          return this._handleDeactivationError(result.then(function() {
            return _this._propagateContainerDeactivationThenBindingAndPreDestroyAsync(binding, instance2, constructor);
          }), constructor);
        }
      }
      var propagateDeactivationResult = this._propagateContainerDeactivationThenBindingAndPreDestroy(binding, instance2, constructor);
      if (isPromise(propagateDeactivationResult)) {
        return this._handleDeactivationError(propagateDeactivationResult, constructor);
      }
    } catch (ex) {
      throw new Error(ON_DEACTIVATION_ERROR(constructor.name, ex.message));
    }
  };
  Container3.prototype._handleDeactivationError = function(asyncResult, constructor) {
    return __awaiter4(this, void 0, void 0, function() {
      var ex_1;
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            _a.trys.push([0, 2, , 3]);
            return [4, asyncResult];
          case 1:
            _a.sent();
            return [3, 3];
          case 2:
            ex_1 = _a.sent();
            throw new Error(ON_DEACTIVATION_ERROR(constructor.name, ex_1.message));
          case 3:
            return [2];
        }
      });
    });
  };
  Container3.prototype._deactivateContainer = function(instance2, deactivationsIterator) {
    var _this = this;
    var deactivation = deactivationsIterator.next();
    while (deactivation.value) {
      var result = deactivation.value(instance2);
      if (isPromise(result)) {
        return result.then(function() {
          return _this._deactivateContainerAsync(instance2, deactivationsIterator);
        });
      }
      deactivation = deactivationsIterator.next();
    }
  };
  Container3.prototype._deactivateContainerAsync = function(instance2, deactivationsIterator) {
    return __awaiter4(this, void 0, void 0, function() {
      var deactivation;
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            deactivation = deactivationsIterator.next();
            _a.label = 1;
          case 1:
            if (!deactivation.value)
              return [3, 3];
            return [4, deactivation.value(instance2)];
          case 2:
            _a.sent();
            deactivation = deactivationsIterator.next();
            return [3, 1];
          case 3:
            return [2];
        }
      });
    });
  };
  Container3.prototype._getContainerModuleHelpersFactory = function() {
    var _this = this;
    var setModuleId = function(bindingToSyntax, moduleId) {
      bindingToSyntax._binding.moduleId = moduleId;
    };
    var getBindFunction = function(moduleId) {
      return function(serviceIdentifier) {
        var bindingToSyntax = _this.bind(serviceIdentifier);
        setModuleId(bindingToSyntax, moduleId);
        return bindingToSyntax;
      };
    };
    var getUnbindFunction = function() {
      return function(serviceIdentifier) {
        return _this.unbind(serviceIdentifier);
      };
    };
    var getUnbindAsyncFunction = function() {
      return function(serviceIdentifier) {
        return _this.unbindAsync(serviceIdentifier);
      };
    };
    var getIsboundFunction = function() {
      return function(serviceIdentifier) {
        return _this.isBound(serviceIdentifier);
      };
    };
    var getRebindFunction = function(moduleId) {
      return function(serviceIdentifier) {
        var bindingToSyntax = _this.rebind(serviceIdentifier);
        setModuleId(bindingToSyntax, moduleId);
        return bindingToSyntax;
      };
    };
    var getOnActivationFunction = function(moduleId) {
      return function(serviceIdentifier, onActivation) {
        _this._moduleActivationStore.addActivation(moduleId, serviceIdentifier, onActivation);
        _this.onActivation(serviceIdentifier, onActivation);
      };
    };
    var getOnDeactivationFunction = function(moduleId) {
      return function(serviceIdentifier, onDeactivation) {
        _this._moduleActivationStore.addDeactivation(moduleId, serviceIdentifier, onDeactivation);
        _this.onDeactivation(serviceIdentifier, onDeactivation);
      };
    };
    return function(mId) {
      return {
        bindFunction: getBindFunction(mId),
        isboundFunction: getIsboundFunction(),
        onActivationFunction: getOnActivationFunction(mId),
        onDeactivationFunction: getOnDeactivationFunction(mId),
        rebindFunction: getRebindFunction(mId),
        unbindFunction: getUnbindFunction(),
        unbindAsyncFunction: getUnbindAsyncFunction()
      };
    };
  };
  Container3.prototype._getAll = function(getArgs) {
    return Promise.all(this._get(getArgs));
  };
  Container3.prototype._get = function(getArgs) {
    var planAndResolveArgs = __assign2(__assign2({}, getArgs), { contextInterceptor: function(context) {
      return context;
    }, targetType: TargetTypeEnum.Variable });
    if (this._middleware) {
      var middlewareResult = this._middleware(planAndResolveArgs);
      if (middlewareResult === void 0 || middlewareResult === null) {
        throw new Error(INVALID_MIDDLEWARE_RETURN);
      }
      return middlewareResult;
    }
    return this._planAndResolve()(planAndResolveArgs);
  };
  Container3.prototype._getButThrowIfAsync = function(getArgs) {
    var result = this._get(getArgs);
    if (isPromiseOrContainsPromise(result)) {
      throw new Error(LAZY_IN_SYNC(getArgs.serviceIdentifier));
    }
    return result;
  };
  Container3.prototype._getAllArgs = function(serviceIdentifier) {
    var getAllArgs = {
      avoidConstraints: true,
      isMultiInject: true,
      serviceIdentifier
    };
    return getAllArgs;
  };
  Container3.prototype._getNotAllArgs = function(serviceIdentifier, isMultiInject, key, value) {
    var getNotAllArgs = {
      avoidConstraints: false,
      isMultiInject,
      serviceIdentifier,
      key,
      value
    };
    return getNotAllArgs;
  };
  Container3.prototype._planAndResolve = function() {
    var _this = this;
    return function(args) {
      var context = plan(_this._metadataReader, _this, args.isMultiInject, args.targetType, args.serviceIdentifier, args.key, args.value, args.avoidConstraints);
      context = args.contextInterceptor(context);
      var result = resolve(context);
      return result;
    };
  };
  Container3.prototype._deactivateIfSingleton = function(binding) {
    var _this = this;
    if (!binding.activated) {
      return;
    }
    if (isPromise(binding.cache)) {
      return binding.cache.then(function(resolved2) {
        return _this._deactivate(binding, resolved2);
      });
    }
    return this._deactivate(binding, binding.cache);
  };
  Container3.prototype._deactivateSingletons = function(bindings) {
    for (var _i = 0, bindings_1 = bindings; _i < bindings_1.length; _i++) {
      var binding = bindings_1[_i];
      var result = this._deactivateIfSingleton(binding);
      if (isPromise(result)) {
        throw new Error(ASYNC_UNBIND_REQUIRED);
      }
    }
  };
  Container3.prototype._deactivateSingletonsAsync = function(bindings) {
    return __awaiter4(this, void 0, void 0, function() {
      var _this = this;
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            return [4, Promise.all(bindings.map(function(b) {
              return _this._deactivateIfSingleton(b);
            }))];
          case 1:
            _a.sent();
            return [2];
        }
      });
    });
  };
  Container3.prototype._propagateContainerDeactivationThenBindingAndPreDestroy = function(binding, instance2, constructor) {
    if (this.parent) {
      return this._deactivate.bind(this.parent)(binding, instance2);
    } else {
      return this._bindingDeactivationAndPreDestroy(binding, instance2, constructor);
    }
  };
  Container3.prototype._propagateContainerDeactivationThenBindingAndPreDestroyAsync = function(binding, instance2, constructor) {
    return __awaiter4(this, void 0, void 0, function() {
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            if (!this.parent)
              return [3, 2];
            return [4, this._deactivate.bind(this.parent)(binding, instance2)];
          case 1:
            _a.sent();
            return [3, 4];
          case 2:
            return [4, this._bindingDeactivationAndPreDestroyAsync(binding, instance2, constructor)];
          case 3:
            _a.sent();
            _a.label = 4;
          case 4:
            return [2];
        }
      });
    });
  };
  Container3.prototype._removeServiceFromDictionary = function(serviceIdentifier) {
    try {
      this._bindingDictionary.remove(serviceIdentifier);
    } catch (e) {
      throw new Error(CANNOT_UNBIND + " " + getServiceIdentifierAsString(serviceIdentifier));
    }
  };
  Container3.prototype._bindingDeactivationAndPreDestroy = function(binding, instance2, constructor) {
    var _this = this;
    if (typeof binding.onDeactivation === "function") {
      var result = binding.onDeactivation(instance2);
      if (isPromise(result)) {
        return result.then(function() {
          return _this._preDestroy(constructor, instance2);
        });
      }
    }
    return this._preDestroy(constructor, instance2);
  };
  Container3.prototype._bindingDeactivationAndPreDestroyAsync = function(binding, instance2, constructor) {
    return __awaiter4(this, void 0, void 0, function() {
      return __generator4(this, function(_a) {
        switch (_a.label) {
          case 0:
            if (!(typeof binding.onDeactivation === "function"))
              return [3, 2];
            return [4, binding.onDeactivation(instance2)];
          case 1:
            _a.sent();
            _a.label = 2;
          case 2:
            return [4, this._preDestroy(constructor, instance2)];
          case 3:
            _a.sent();
            return [2];
        }
      });
    });
  };
  return Container3;
}();

// node_modules/inversify/es/container/container_module.js
var ContainerModule = function() {
  function ContainerModule2(registry) {
    this.id = id();
    this.registry = registry;
  }
  return ContainerModule2;
}();
var AsyncContainerModule = function() {
  function AsyncContainerModule2(registry) {
    this.id = id();
    this.registry = registry;
  }
  return AsyncContainerModule2;
}();

// node_modules/inversify/es/utils/js.js
function getFirstArrayDuplicate(array) {
  var seenValues = /* @__PURE__ */ new Set();
  for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
    var entry = array_1[_i];
    if (seenValues.has(entry)) {
      return entry;
    } else {
      seenValues.add(entry);
    }
  }
  return void 0;
}

// node_modules/inversify/es/annotation/decorator_utils.js
function targetIsConstructorFunction(target) {
  return target.prototype !== void 0;
}
function _throwIfMethodParameter(parameterName) {
  if (parameterName !== void 0) {
    throw new Error(INVALID_DECORATOR_OPERATION);
  }
}
function tagParameter(annotationTarget, parameterName, parameterIndex, metadata) {
  _throwIfMethodParameter(parameterName);
  _tagParameterOrProperty(TAGGED, annotationTarget, parameterIndex.toString(), metadata);
}
function tagProperty(annotationTarget, propertyName, metadata) {
  if (targetIsConstructorFunction(annotationTarget)) {
    throw new Error(INVALID_DECORATOR_OPERATION);
  }
  _tagParameterOrProperty(TAGGED_PROP, annotationTarget.constructor, propertyName, metadata);
}
function _ensureNoMetadataKeyDuplicates(metadata) {
  var metadatas = [];
  if (Array.isArray(metadata)) {
    metadatas = metadata;
    var duplicate = getFirstArrayDuplicate(metadatas.map(function(md) {
      return md.key;
    }));
    if (duplicate !== void 0) {
      throw new Error(DUPLICATED_METADATA + " " + duplicate.toString());
    }
  } else {
    metadatas = [metadata];
  }
  return metadatas;
}
function _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) {
  var metadatas = _ensureNoMetadataKeyDuplicates(metadata);
  var paramsOrPropertiesMetadata = {};
  if (Reflect.hasOwnMetadata(metadataKey, annotationTarget)) {
    paramsOrPropertiesMetadata = Reflect.getMetadata(metadataKey, annotationTarget);
  }
  var paramOrPropertyMetadata = paramsOrPropertiesMetadata[key];
  if (paramOrPropertyMetadata === void 0) {
    paramOrPropertyMetadata = [];
  } else {
    var _loop_1 = function(m2) {
      if (metadatas.some(function(md) {
        return md.key === m2.key;
      })) {
        throw new Error(DUPLICATED_METADATA + " " + m2.key.toString());
      }
    };
    for (var _i = 0, paramOrPropertyMetadata_1 = paramOrPropertyMetadata; _i < paramOrPropertyMetadata_1.length; _i++) {
      var m = paramOrPropertyMetadata_1[_i];
      _loop_1(m);
    }
  }
  paramOrPropertyMetadata.push.apply(paramOrPropertyMetadata, metadatas);
  paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata;
  Reflect.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
}
function createTaggedDecorator(metadata) {
  return function(target, targetKey, indexOrPropertyDescriptor) {
    if (typeof indexOrPropertyDescriptor === "number") {
      tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
    } else {
      tagProperty(target, targetKey, metadata);
    }
  };
}

// node_modules/inversify/es/annotation/injectable.js
function injectable() {
  return function(target) {
    if (Reflect.hasOwnMetadata(PARAM_TYPES, target)) {
      throw new Error(DUPLICATED_INJECTABLE_DECORATOR);
    }
    var types = Reflect.getMetadata(DESIGN_PARAM_TYPES, target) || [];
    Reflect.defineMetadata(PARAM_TYPES, types, target);
    return target;
  };
}

// node_modules/inversify/es/annotation/named.js
function named(name) {
  return createTaggedDecorator(new Metadata(NAMED_TAG, name));
}

// node_modules/inversify/es/annotation/inject_base.js
function injectBase(metadataKey) {
  return function(serviceIdentifier) {
    return function(target, targetKey, indexOrPropertyDescriptor) {
      if (serviceIdentifier === void 0) {
        var className = typeof target === "function" ? target.name : target.constructor.name;
        throw new Error(UNDEFINED_INJECT_ANNOTATION(className));
      }
      return createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
    };
  };
}

// node_modules/inversify/es/annotation/inject.js
var inject = injectBase(INJECT_TAG);

// node_modules/inversify/es/annotation/multi_inject.js
var multiInject = injectBase(MULTI_INJECT_TAG);

// config/inversify.types.ts
var SI = {
  "factory:replacer": "",
  "event:dispatcher": "",
  "alias:modifier": "",
  "alias:modifier:strategy": "",
  "alias:modifier:validator": "",
  cache: "",
  "component:black_white_list": "",
  "component:extractor": "",
  "component:extractor:strategy": "",
  "creator:creator": "",
  "creator:fallback": "",
  "creator:template": "",
  delimiter: "",
  "facade:obsidian": "",
  "factory:alias:modifier:strategy": "",
  "factory:alias:modifier:validator": "",
  "factory:feature": "",
  "factory:metadata:cache": "",
  "factory:obsidian:active:file": "",
  "factory:obsidian:modal": "",
  "factory:obsidian:file": "",
  "factory:obsidian:file_modifiable": "",
  "factory:obsidian:meta": "",
  "factory:placeholder": "",
  "factory:placeholder:resolver": "",
  "factory:creator:template": "",
  "factory:template:resolver": "",
  "newable:obsidian:chooser": "",
  feature: "",
  "feature:composer": "",
  "feature:service": "",
  "feature:alias:config": "",
  "feature:notelink:approve": "",
  "feature:config": "",
  filter: "",
  "getter:delimiter": "",
  listener: "",
  logger: "",
  "feature:helper": "",
  "logger:composer": "",
  "manager:composer": "",
  "obsidian:app": "",
  "obsidian:plugin": "",
  placeholder: "",
  "placeholder:brackets": "",
  "placeholder:meta": "",
  resolver: "",
  "resolver:service": "",
  "factory:resolver:template": "",
  "factory:resolver:resolver": "",
  "service:note:link": "",
  "service:fake_title_element": "",
  "service:search:dom:wrapper": "",
  "settings:feature:builder": "",
  "settings:builder": "",
  "factory:settings:feature:builder": "",
  "factory:settings:builder": "",
  "settings:storage": "",
  "template:pattern": "",
  api: "",
  defer: "",
  "factory:api": "",
  "factory:processor": "",
  processor: "",
  "processor:args": ""
};
for (const key of Object.keys(SI)) {
  SI[key] = Symbol.for(key);
}
var inversify_types_default = SI;

// src/i18n/Locale.ts
var import_obsidian = require("obsidian");

// src/Enum.ts
var Feature = /* @__PURE__ */ ((Feature4) => {
  Feature4["Explorer"] = "explorer";
  Feature4["ExplorerSort"] = "explorer:sort";
  Feature4["Graph"] = "graph";
  Feature4["Header"] = "header";
  Feature4["Starred"] = "starred";
  Feature4["Search"] = "search" /* S */;
  Feature4["Tab"] = "tab";
  Feature4["Alias"] = "alias";
  Feature4["Suggest"] = "suggest";
  Feature4["InlineTitle"] = "inlineTitle";
  Feature4["Canvas"] = "canvas";
  Feature4["Backlink"] = "backlink" /* BL */;
  Feature4["NoteLink"] = "noteLink";
  return Feature4;
})(Feature || {});
var Managers = [
  "explorer" /* Explorer */,
  "graph" /* Graph */,
  "header" /* Header */,
  "starred" /* Starred */,
  "tab" /* Tab */,
  "inlineTitle" /* InlineTitle */,
  "canvas" /* Canvas */
];
var GITHUB_DOCS = "https://github.com/snezhig/obsidian-front-matter-title/blob/master/docs/";

// src/i18n/en/index.ts
var en = {
  validator: "Validator",
  strategy: "Strategy",
  cancel: "Cancel",
  apply: "Apply",
  feature: {
    ["alias" /* Alias */]: {
      name: "Alias",
      desc: "Modify alias in metadata cache. The real alias will not be affected",
      validator: {
        auto: {
          name: "Frontmatter Auto",
          desc: "If frontmatter does not exist, it will be created in cache. Side-effects may occur."
        },
        required: {
          name: "Frontmatter Required",
          desc: "Only files with frontmatter will be processed."
        }
      },
      strategy: {
        ensure: {
          name: "Ensure",
          desc: "Set title as an alias only if the one does not exist"
        },
        adjust: {
          name: "Adjust",
          desc: "Add title to alias and without affect on existing alias"
        },
        replace: {
          name: "Replace",
          desc: "Replace current alias with title"
        }
      }
    },
    ["explorer" /* Explorer */]: {
      name: "Explorer",
      desc: "Replace shown titles in the file explorer"
    },
    ["explorer:sort" /* ExplorerSort */]: {
      name: "Explorer sort",
      desc: "Sort files in explorer by titles from Explorer feature"
    },
    ["graph" /* Graph */]: {
      name: "Graph",
      desc: "Replace shown titles in the graph/local-graph"
    },
    ["header" /* Header */]: {
      name: "Header",
      desc: "Replace titles in header of leaves and update them"
    },
    ["starred" /* Starred */]: {
      name: "Starred",
      desc: "Replace shown titles in built-in starred plugin"
    },
    ["search" /* Search */]: {
      name: "Search",
      desc: "Replace shown titles in search leaf"
    },
    ["suggest" /* Suggest */]: {
      name: "Suggest",
      desc: "Replace shown titles in suggest modals"
    },
    ["tab" /* Tab */]: {
      name: "Tabs",
      desc: "Replace shown titles in tabs"
    },
    ["inlineTitle" /* InlineTitle */]: {
      name: "Inline",
      desc: "Replace shown titles in Inline Title"
    },
    ["canvas" /* Canvas */]: {
      name: "Canvas",
      desc: "Replace shown titles in Canvas"
    },
    ["backlink" /* Backlink */]: {
      name: "Backlink",
      desc: "Replace shown titles in Backlink(Linked mentions)"
    },
    ["noteLink" /* NoteLink */]: {
      name: "Note Link",
      desc: "Replace internal links in files",
      strategy: {
        all: "Repalce all links",
        onlyEmpty: "Replace only links without alias"
      },
      approval: {
        showModal: "Show approve modal",
        auto: "Use auto approve"
      }
    }
  },
  manage: "Manage",
  template: {
    features: {
      name: "Features' templates",
      desc: "Manage templates for each feature individually"
    },
    main: "Main",
    fallback: "Fallback",
    placeholder: "Type a template",
    commmon: {
      main: {
        name: "Common main template",
        desc: `Set a yaml path, which value will be used as a file title. Value must be string or numeric. Also you can use template-like path using "{{ }}".
				Also you can use #heading to use first Heading from a file or _basename and another reserved words. 
				See Readme to find out more`
      },
      fallback: {
        name: "Common fallback template",
        desc: "This template will be used as a fallback option if the main template is not resolved"
      }
    },
    used: "Common template will be used. It's value is {{value}}",
    specific: "Current template will be used for this feature"
  },
  settings: "Settings for plugin",
  rule: {
    name: "Rules",
    path: {
      name: "File path rule",
      black: {
        name: "Black list mode",
        desc: "Files that are located by paths will be ignored by plugin. Each path must be written with new line."
      },
      white: {
        name: "White list mode",
        desc: "Files that are located by paths will be processed by plugin. Each path must be written with new line."
      }
    },
    delimiter: {
      name: "List values",
      desc: "Set the rule about how to process list values",
      first: "Use first value",
      join: "Join all by delimiter",
      placeholder: {
        first: "First value will be used",
        join: "Type a delimiter"
      }
    }
  },
  features: "Features",
  util: "Util",
  coffee: "If you like this plugin and you would like to help support continued development, you can use the buttons below:",
  debug_info: {
    title: "Debug info",
    desc: "Show debug info and caught errors in console"
  },
  boot_delay: {
    title: "Boot delay",
    desc: "Plugin will be loaded with specified delay in ms"
  },
  disabled: "Disabled",
  processor: {
    name: "Processor",
    desc: "Modifies resolved title",
    replace: {
      name: "Replace",
      desc: "What will be executed",
      pattern: {
        name: "Pattern",
        desc: "Will be used as a first argument of RegExp first, and then as a first argument of replace()"
      },
      flags: {
        name: "Flags",
        desc: "Will be used as a second argument of new RegExp"
      },
      replacement: {
        name: "Replacement",
        desc: "Will be used as a second argument of replace()"
      }
    },
    function: {
      name: "Function",
      desc: "How it will work:",
      valueDesc: "Your value of text area"
    }
  },
  command: {
    features: {
      reload: "Reload features",
      disable: "Disable features"
    }
  }
};
var en_default = en;

// src/i18n/ru/index.ts
var ru = {};
var ru_default = ru;

// node_modules/i18next/dist/esm/i18next.js
var consoleLogger = {
  type: "logger",
  log(args) {
    this.output("log", args);
  },
  warn(args) {
    this.output("warn", args);
  },
  error(args) {
    this.output("error", args);
  },
  output(type, args) {
    if (console && console[type])
      console[type].apply(console, args);
  }
};
var Logger = class _Logger {
  constructor(concreteLogger) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    this.init(concreteLogger, options);
  }
  init(concreteLogger) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    this.prefix = options.prefix || "i18next:";
    this.logger = concreteLogger || consoleLogger;
    this.options = options;
    this.debug = options.debug;
  }
  log() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    return this.forward(args, "log", "", true);
  }
  warn() {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }
    return this.forward(args, "warn", "", true);
  }
  error() {
    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      args[_key3] = arguments[_key3];
    }
    return this.forward(args, "error", "");
  }
  deprecate() {
    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      args[_key4] = arguments[_key4];
    }
    return this.forward(args, "warn", "WARNING DEPRECATED: ", true);
  }
  forward(args, lvl, prefix, debugOnly) {
    if (debugOnly && !this.debug)
      return null;
    if (typeof args[0] === "string")
      args[0] = `${prefix}${this.prefix} ${args[0]}`;
    return this.logger[lvl](args);
  }
  create(moduleName) {
    return new _Logger(this.logger, {
      ...{
        prefix: `${this.prefix}:${moduleName}:`
      },
      ...this.options
    });
  }
  clone(options) {
    options = options || this.options;
    options.prefix = options.prefix || this.prefix;
    return new _Logger(this.logger, options);
  }
};
var baseLogger = new Logger();
var EventEmitter = class {
  constructor() {
    this.observers = {};
  }
  on(events, listener) {
    events.split(" ").forEach((event) => {
      this.observers[event] = this.observers[event] || [];
      this.observers[event].push(listener);
    });
    return this;
  }
  off(event, listener) {
    if (!this.observers[event])
      return;
    if (!listener) {
      delete this.observers[event];
      return;
    }
    this.observers[event] = this.observers[event].filter((l) => l !== listener);
  }
  emit(event) {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    if (this.observers[event]) {
      const cloned = [].concat(this.observers[event]);
      cloned.forEach((observer) => {
        observer(...args);
      });
    }
    if (this.observers["*"]) {
      const cloned = [].concat(this.observers["*"]);
      cloned.forEach((observer) => {
        observer.apply(observer, [event, ...args]);
      });
    }
  }
};
function defer() {
  let res;
  let rej;
  const promise = new Promise((resolve2, reject) => {
    res = resolve2;
    rej = reject;
  });
  promise.resolve = res;
  promise.reject = rej;
  return promise;
}
function makeString(object) {
  if (object == null)
    return "";
  return "" + object;
}
function copy(a, s, t3) {
  a.forEach((m) => {
    if (s[m])
      t3[m] = s[m];
  });
}
function getLastOfPath(object, path, Empty) {
  function cleanKey(key) {
    return key && key.indexOf("###") > -1 ? key.replace(/###/g, ".") : key;
  }
  function canNotTraverseDeeper() {
    return !object || typeof object === "string";
  }
  const stack = typeof path !== "string" ? [].concat(path) : path.split(".");
  while (stack.length > 1) {
    if (canNotTraverseDeeper())
      return {};
    const key = cleanKey(stack.shift());
    if (!object[key] && Empty)
      object[key] = new Empty();
    if (Object.prototype.hasOwnProperty.call(object, key)) {
      object = object[key];
    } else {
      object = {};
    }
  }
  if (canNotTraverseDeeper())
    return {};
  return {
    obj: object,
    k: cleanKey(stack.shift())
  };
}
function setPath(object, path, newValue) {
  const {
    obj,
    k
  } = getLastOfPath(object, path, Object);
  obj[k] = newValue;
}
function pushPath(object, path, newValue, concat) {
  const {
    obj,
    k
  } = getLastOfPath(object, path, Object);
  obj[k] = obj[k] || [];
  if (concat)
    obj[k] = obj[k].concat(newValue);
  if (!concat)
    obj[k].push(newValue);
}
function getPath(object, path) {
  const {
    obj,
    k
  } = getLastOfPath(object, path);
  if (!obj)
    return void 0;
  return obj[k];
}
function getPathWithDefaults(data, defaultData, key) {
  const value = getPath(data, key);
  if (value !== void 0) {
    return value;
  }
  return getPath(defaultData, key);
}
function deepExtend(target, source, overwrite) {
  for (const prop in source) {
    if (prop !== "__proto__" && prop !== "constructor") {
      if (prop in target) {
        if (typeof target[prop] === "string" || target[prop] instanceof String || typeof source[prop] === "string" || source[prop] instanceof String) {
          if (overwrite)
            target[prop] = source[prop];
        } else {
          deepExtend(target[prop], source[prop], overwrite);
        }
      } else {
        target[prop] = source[prop];
      }
    }
  }
  return target;
}
function regexEscape(str) {
  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
}
var _entityMap = {
  "&": "&amp;",
  "<": "&lt;",
  ">": "&gt;",
  '"': "&quot;",
  "'": "&#39;",
  "/": "&#x2F;"
};
function escape(data) {
  if (typeof data === "string") {
    return data.replace(/[&<>"'\/]/g, (s) => _entityMap[s]);
  }
  return data;
}
var chars = [" ", ",", "?", "!", ";"];
function looksLikeObjectPath(key, nsSeparator, keySeparator) {
  nsSeparator = nsSeparator || "";
  keySeparator = keySeparator || "";
  const possibleChars = chars.filter((c) => nsSeparator.indexOf(c) < 0 && keySeparator.indexOf(c) < 0);
  if (possibleChars.length === 0)
    return true;
  const r = new RegExp(`(${possibleChars.map((c) => c === "?" ? "\\?" : c).join("|")})`);
  let matched = !r.test(key);
  if (!matched) {
    const ki = key.indexOf(keySeparator);
    if (ki > 0 && !r.test(key.substring(0, ki))) {
      matched = true;
    }
  }
  return matched;
}
function deepFind(obj, path) {
  let keySeparator = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ".";
  if (!obj)
    return void 0;
  if (obj[path])
    return obj[path];
  const paths = path.split(keySeparator);
  let current = obj;
  for (let i = 0; i < paths.length; ++i) {
    if (!current)
      return void 0;
    if (typeof current[paths[i]] === "string" && i + 1 < paths.length) {
      return void 0;
    }
    if (current[paths[i]] === void 0) {
      let j = 2;
      let p = paths.slice(i, i + j).join(keySeparator);
      let mix = current[p];
      while (mix === void 0 && paths.length > i + j) {
        j++;
        p = paths.slice(i, i + j).join(keySeparator);
        mix = current[p];
      }
      if (mix === void 0)
        return void 0;
      if (mix === null)
        return null;
      if (path.endsWith(p)) {
        if (typeof mix === "string")
          return mix;
        if (p && typeof mix[p] === "string")
          return mix[p];
      }
      const joinedPath = paths.slice(i + j).join(keySeparator);
      if (joinedPath)
        return deepFind(mix, joinedPath, keySeparator);
      return void 0;
    }
    current = current[paths[i]];
  }
  return current;
}
function getCleanedCode(code) {
  if (code && code.indexOf("_") > 0)
    return code.replace("_", "-");
  return code;
}
var ResourceStore = class extends EventEmitter {
  constructor(data) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
      ns: ["translation"],
      defaultNS: "translation"
    };
    super();
    this.data = data || {};
    this.options = options;
    if (this.options.keySeparator === void 0) {
      this.options.keySeparator = ".";
    }
    if (this.options.ignoreJSONStructure === void 0) {
      this.options.ignoreJSONStructure = true;
    }
  }
  addNamespaces(ns) {
    if (this.options.ns.indexOf(ns) < 0) {
      this.options.ns.push(ns);
    }
  }
  removeNamespaces(ns) {
    const index = this.options.ns.indexOf(ns);
    if (index > -1) {
      this.options.ns.splice(index, 1);
    }
  }
  getResource(lng, ns, key) {
    let options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
    const keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
    const ignoreJSONStructure = options.ignoreJSONStructure !== void 0 ? options.ignoreJSONStructure : this.options.ignoreJSONStructure;
    let path = [lng, ns];
    if (key && typeof key !== "string")
      path = path.concat(key);
    if (key && typeof key === "string")
      path = path.concat(keySeparator ? key.split(keySeparator) : key);
    if (lng.indexOf(".") > -1) {
      path = lng.split(".");
    }
    const result = getPath(this.data, path);
    if (result || !ignoreJSONStructure || typeof key !== "string")
      return result;
    return deepFind(this.data && this.data[lng] && this.data[lng][ns], key, keySeparator);
  }
  addResource(lng, ns, key, value) {
    let options = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : {
      silent: false
    };
    const keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
    let path = [lng, ns];
    if (key)
      path = path.concat(keySeparator ? key.split(keySeparator) : key);
    if (lng.indexOf(".") > -1) {
      path = lng.split(".");
      value = ns;
      ns = path[1];
    }
    this.addNamespaces(ns);
    setPath(this.data, path, value);
    if (!options.silent)
      this.emit("added", lng, ns, key, value);
  }
  addResources(lng, ns, resources) {
    let options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {
      silent: false
    };
    for (const m in resources) {
      if (typeof resources[m] === "string" || Object.prototype.toString.apply(resources[m]) === "[object Array]")
        this.addResource(lng, ns, m, resources[m], {
          silent: true
        });
    }
    if (!options.silent)
      this.emit("added", lng, ns, resources);
  }
  addResourceBundle(lng, ns, resources, deep, overwrite) {
    let options = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : {
      silent: false
    };
    let path = [lng, ns];
    if (lng.indexOf(".") > -1) {
      path = lng.split(".");
      deep = resources;
      resources = ns;
      ns = path[1];
    }
    this.addNamespaces(ns);
    let pack = getPath(this.data, path) || {};
    if (deep) {
      deepExtend(pack, resources, overwrite);
    } else {
      pack = {
        ...pack,
        ...resources
      };
    }
    setPath(this.data, path, pack);
    if (!options.silent)
      this.emit("added", lng, ns, resources);
  }
  removeResourceBundle(lng, ns) {
    if (this.hasResourceBundle(lng, ns)) {
      delete this.data[lng][ns];
    }
    this.removeNamespaces(ns);
    this.emit("removed", lng, ns);
  }
  hasResourceBundle(lng, ns) {
    return this.getResource(lng, ns) !== void 0;
  }
  getResourceBundle(lng, ns) {
    if (!ns)
      ns = this.options.defaultNS;
    if (this.options.compatibilityAPI === "v1")
      return {
        ...{},
        ...this.getResource(lng, ns)
      };
    return this.getResource(lng, ns);
  }
  getDataByLanguage(lng) {
    return this.data[lng];
  }
  hasLanguageSomeTranslations(lng) {
    const data = this.getDataByLanguage(lng);
    const n = data && Object.keys(data) || [];
    return !!n.find((v) => data[v] && Object.keys(data[v]).length > 0);
  }
  toJSON() {
    return this.data;
  }
};
var postProcessor = {
  processors: {},
  addPostProcessor(module2) {
    this.processors[module2.name] = module2;
  },
  handle(processors, value, key, options, translator) {
    processors.forEach((processor) => {
      if (this.processors[processor])
        value = this.processors[processor].process(value, key, options, translator);
    });
    return value;
  }
};
var checkedLoadedFor = {};
var Translator = class _Translator extends EventEmitter {
  constructor(services) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    super();
    copy(["resourceStore", "languageUtils", "pluralResolver", "interpolator", "backendConnector", "i18nFormat", "utils"], services, this);
    this.options = options;
    if (this.options.keySeparator === void 0) {
      this.options.keySeparator = ".";
    }
    this.logger = baseLogger.create("translator");
  }
  changeLanguage(lng) {
    if (lng)
      this.language = lng;
  }
  exists(key) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
      interpolation: {}
    };
    if (key === void 0 || key === null) {
      return false;
    }
    const resolved2 = this.resolve(key, options);
    return resolved2 && resolved2.res !== void 0;
  }
  extractFromKey(key, options) {
    let nsSeparator = options.nsSeparator !== void 0 ? options.nsSeparator : this.options.nsSeparator;
    if (nsSeparator === void 0)
      nsSeparator = ":";
    const keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
    let namespaces = options.ns || this.options.defaultNS || [];
    const wouldCheckForNsInKey = nsSeparator && key.indexOf(nsSeparator) > -1;
    const seemsNaturalLanguage = !this.options.userDefinedKeySeparator && !options.keySeparator && !this.options.userDefinedNsSeparator && !options.nsSeparator && !looksLikeObjectPath(key, nsSeparator, keySeparator);
    if (wouldCheckForNsInKey && !seemsNaturalLanguage) {
      const m = key.match(this.interpolator.nestingRegexp);
      if (m && m.length > 0) {
        return {
          key,
          namespaces
        };
      }
      const parts = key.split(nsSeparator);
      if (nsSeparator !== keySeparator || nsSeparator === keySeparator && this.options.ns.indexOf(parts[0]) > -1)
        namespaces = parts.shift();
      key = parts.join(keySeparator);
    }
    if (typeof namespaces === "string")
      namespaces = [namespaces];
    return {
      key,
      namespaces
    };
  }
  translate(keys, options, lastKey) {
    if (typeof options !== "object" && this.options.overloadTranslationOptionHandler) {
      options = this.options.overloadTranslationOptionHandler(arguments);
    }
    if (typeof options === "object")
      options = {
        ...options
      };
    if (!options)
      options = {};
    if (keys === void 0 || keys === null)
      return "";
    if (!Array.isArray(keys))
      keys = [String(keys)];
    const returnDetails = options.returnDetails !== void 0 ? options.returnDetails : this.options.returnDetails;
    const keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
    const {
      key,
      namespaces
    } = this.extractFromKey(keys[keys.length - 1], options);
    const namespace = namespaces[namespaces.length - 1];
    const lng = options.lng || this.language;
    const appendNamespaceToCIMode = options.appendNamespaceToCIMode || this.options.appendNamespaceToCIMode;
    if (lng && lng.toLowerCase() === "cimode") {
      if (appendNamespaceToCIMode) {
        const nsSeparator = options.nsSeparator || this.options.nsSeparator;
        if (returnDetails) {
          return {
            res: `${namespace}${nsSeparator}${key}`,
            usedKey: key,
            exactUsedKey: key,
            usedLng: lng,
            usedNS: namespace
          };
        }
        return `${namespace}${nsSeparator}${key}`;
      }
      if (returnDetails) {
        return {
          res: key,
          usedKey: key,
          exactUsedKey: key,
          usedLng: lng,
          usedNS: namespace
        };
      }
      return key;
    }
    const resolved2 = this.resolve(keys, options);
    let res = resolved2 && resolved2.res;
    const resUsedKey = resolved2 && resolved2.usedKey || key;
    const resExactUsedKey = resolved2 && resolved2.exactUsedKey || key;
    const resType = Object.prototype.toString.apply(res);
    const noObject = ["[object Number]", "[object Function]", "[object RegExp]"];
    const joinArrays = options.joinArrays !== void 0 ? options.joinArrays : this.options.joinArrays;
    const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
    const handleAsObject = typeof res !== "string" && typeof res !== "boolean" && typeof res !== "number";
    if (handleAsObjectInI18nFormat && res && handleAsObject && noObject.indexOf(resType) < 0 && !(typeof joinArrays === "string" && resType === "[object Array]")) {
      if (!options.returnObjects && !this.options.returnObjects) {
        if (!this.options.returnedObjectHandler) {
          this.logger.warn("accessing an object - but returnObjects options is not enabled!");
        }
        const r = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, res, {
          ...options,
          ns: namespaces
        }) : `key '${key} (${this.language})' returned an object instead of string.`;
        if (returnDetails) {
          resolved2.res = r;
          return resolved2;
        }
        return r;
      }
      if (keySeparator) {
        const resTypeIsArray = resType === "[object Array]";
        const copy2 = resTypeIsArray ? [] : {};
        const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
        for (const m in res) {
          if (Object.prototype.hasOwnProperty.call(res, m)) {
            const deepKey = `${newKeyToUse}${keySeparator}${m}`;
            copy2[m] = this.translate(deepKey, {
              ...options,
              ...{
                joinArrays: false,
                ns: namespaces
              }
            });
            if (copy2[m] === deepKey)
              copy2[m] = res[m];
          }
        }
        res = copy2;
      }
    } else if (handleAsObjectInI18nFormat && typeof joinArrays === "string" && resType === "[object Array]") {
      res = res.join(joinArrays);
      if (res)
        res = this.extendTranslation(res, keys, options, lastKey);
    } else {
      let usedDefault = false;
      let usedKey = false;
      const needsPluralHandling = options.count !== void 0 && typeof options.count !== "string";
      const hasDefaultValue = _Translator.hasDefaultValue(options);
      const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, options) : "";
      const defaultValueSuffixOrdinalFallback = options.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, {
        ordinal: false
      }) : "";
      const defaultValue = options[`defaultValue${defaultValueSuffix}`] || options[`defaultValue${defaultValueSuffixOrdinalFallback}`] || options.defaultValue;
      if (!this.isValidLookup(res) && hasDefaultValue) {
        usedDefault = true;
        res = defaultValue;
      }
      if (!this.isValidLookup(res)) {
        usedKey = true;
        res = key;
      }
      const missingKeyNoValueFallbackToKey = options.missingKeyNoValueFallbackToKey || this.options.missingKeyNoValueFallbackToKey;
      const resForMissing = missingKeyNoValueFallbackToKey && usedKey ? void 0 : res;
      const updateMissing = hasDefaultValue && defaultValue !== res && this.options.updateMissing;
      if (usedKey || usedDefault || updateMissing) {
        this.logger.log(updateMissing ? "updateKey" : "missingKey", lng, namespace, key, updateMissing ? defaultValue : res);
        if (keySeparator) {
          const fk = this.resolve(key, {
            ...options,
            keySeparator: false
          });
          if (fk && fk.res)
            this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.");
        }
        let lngs = [];
        const fallbackLngs = this.languageUtils.getFallbackCodes(this.options.fallbackLng, options.lng || this.language);
        if (this.options.saveMissingTo === "fallback" && fallbackLngs && fallbackLngs[0]) {
          for (let i = 0; i < fallbackLngs.length; i++) {
            lngs.push(fallbackLngs[i]);
          }
        } else if (this.options.saveMissingTo === "all") {
          lngs = this.languageUtils.toResolveHierarchy(options.lng || this.language);
        } else {
          lngs.push(options.lng || this.language);
        }
        const send = (l, k, specificDefaultValue) => {
          const defaultForMissing = hasDefaultValue && specificDefaultValue !== res ? specificDefaultValue : resForMissing;
          if (this.options.missingKeyHandler) {
            this.options.missingKeyHandler(l, namespace, k, defaultForMissing, updateMissing, options);
          } else if (this.backendConnector && this.backendConnector.saveMissing) {
            this.backendConnector.saveMissing(l, namespace, k, defaultForMissing, updateMissing, options);
          }
          this.emit("missingKey", l, namespace, k, res);
        };
        if (this.options.saveMissing) {
          if (this.options.saveMissingPlurals && needsPluralHandling) {
            lngs.forEach((language) => {
              this.pluralResolver.getSuffixes(language, options).forEach((suffix) => {
                send([language], key + suffix, options[`defaultValue${suffix}`] || defaultValue);
              });
            });
          } else {
            send(lngs, key, defaultValue);
          }
        }
      }
      res = this.extendTranslation(res, keys, options, resolved2, lastKey);
      if (usedKey && res === key && this.options.appendNamespaceToMissingKey)
        res = `${namespace}:${key}`;
      if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
        if (this.options.compatibilityAPI !== "v1") {
          res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}:${key}` : key, usedDefault ? res : void 0);
        } else {
          res = this.options.parseMissingKeyHandler(res);
        }
      }
    }
    if (returnDetails) {
      resolved2.res = res;
      return resolved2;
    }
    return res;
  }
  extendTranslation(res, key, options, resolved2, lastKey) {
    var _this = this;
    if (this.i18nFormat && this.i18nFormat.parse) {
      res = this.i18nFormat.parse(res, {
        ...this.options.interpolation.defaultVariables,
        ...options
      }, resolved2.usedLng, resolved2.usedNS, resolved2.usedKey, {
        resolved: resolved2
      });
    } else if (!options.skipInterpolation) {
      if (options.interpolation)
        this.interpolator.init({
          ...options,
          ...{
            interpolation: {
              ...this.options.interpolation,
              ...options.interpolation
            }
          }
        });
      const skipOnVariables = typeof res === "string" && (options && options.interpolation && options.interpolation.skipOnVariables !== void 0 ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables);
      let nestBef;
      if (skipOnVariables) {
        const nb = res.match(this.interpolator.nestingRegexp);
        nestBef = nb && nb.length;
      }
      let data = options.replace && typeof options.replace !== "string" ? options.replace : options;
      if (this.options.interpolation.defaultVariables)
        data = {
          ...this.options.interpolation.defaultVariables,
          ...data
        };
      res = this.interpolator.interpolate(res, data, options.lng || this.language, options);
      if (skipOnVariables) {
        const na = res.match(this.interpolator.nestingRegexp);
        const nestAft = na && na.length;
        if (nestBef < nestAft)
          options.nest = false;
      }
      if (!options.lng && this.options.compatibilityAPI !== "v1" && resolved2 && resolved2.res)
        options.lng = resolved2.usedLng;
      if (options.nest !== false)
        res = this.interpolator.nest(res, function() {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          if (lastKey && lastKey[0] === args[0] && !options.context) {
            _this.logger.warn(`It seems you are nesting recursively key: ${args[0]} in key: ${key[0]}`);
            return null;
          }
          return _this.translate(...args, key);
        }, options);
      if (options.interpolation)
        this.interpolator.reset();
    }
    const postProcess = options.postProcess || this.options.postProcess;
    const postProcessorNames = typeof postProcess === "string" ? [postProcess] : postProcess;
    if (res !== void 0 && res !== null && postProcessorNames && postProcessorNames.length && options.applyPostProcessor !== false) {
      res = postProcessor.handle(postProcessorNames, res, key, this.options && this.options.postProcessPassResolved ? {
        i18nResolved: resolved2,
        ...options
      } : options, this);
    }
    return res;
  }
  resolve(keys) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    let found;
    let usedKey;
    let exactUsedKey;
    let usedLng;
    let usedNS;
    if (typeof keys === "string")
      keys = [keys];
    keys.forEach((k) => {
      if (this.isValidLookup(found))
        return;
      const extracted = this.extractFromKey(k, options);
      const key = extracted.key;
      usedKey = key;
      let namespaces = extracted.namespaces;
      if (this.options.fallbackNS)
        namespaces = namespaces.concat(this.options.fallbackNS);
      const needsPluralHandling = options.count !== void 0 && typeof options.count !== "string";
      const needsZeroSuffixLookup = needsPluralHandling && !options.ordinal && options.count === 0 && this.pluralResolver.shouldUseIntlApi();
      const needsContextHandling = options.context !== void 0 && (typeof options.context === "string" || typeof options.context === "number") && options.context !== "";
      const codes = options.lngs ? options.lngs : this.languageUtils.toResolveHierarchy(options.lng || this.language, options.fallbackLng);
      namespaces.forEach((ns) => {
        if (this.isValidLookup(found))
          return;
        usedNS = ns;
        if (!checkedLoadedFor[`${codes[0]}-${ns}`] && this.utils && this.utils.hasLoadedNamespace && !this.utils.hasLoadedNamespace(usedNS)) {
          checkedLoadedFor[`${codes[0]}-${ns}`] = true;
          this.logger.warn(`key "${usedKey}" for languages "${codes.join(", ")}" won't get resolved as namespace "${usedNS}" was not yet loaded`, "This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!");
        }
        codes.forEach((code) => {
          if (this.isValidLookup(found))
            return;
          usedLng = code;
          const finalKeys = [key];
          if (this.i18nFormat && this.i18nFormat.addLookupKeys) {
            this.i18nFormat.addLookupKeys(finalKeys, key, code, ns, options);
          } else {
            let pluralSuffix;
            if (needsPluralHandling)
              pluralSuffix = this.pluralResolver.getSuffix(code, options.count, options);
            const zeroSuffix = `${this.options.pluralSeparator}zero`;
            const ordinalPrefix = `${this.options.pluralSeparator}ordinal${this.options.pluralSeparator}`;
            if (needsPluralHandling) {
              finalKeys.push(key + pluralSuffix);
              if (options.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
                finalKeys.push(key + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
              }
              if (needsZeroSuffixLookup) {
                finalKeys.push(key + zeroSuffix);
              }
            }
            if (needsContextHandling) {
              const contextKey = `${key}${this.options.contextSeparator}${options.context}`;
              finalKeys.push(contextKey);
              if (needsPluralHandling) {
                finalKeys.push(contextKey + pluralSuffix);
                if (options.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
                  finalKeys.push(contextKey + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
                }
                if (needsZeroSuffixLookup) {
                  finalKeys.push(contextKey + zeroSuffix);
                }
              }
            }
          }
          let possibleKey;
          while (possibleKey = finalKeys.pop()) {
            if (!this.isValidLookup(found)) {
              exactUsedKey = possibleKey;
              found = this.getResource(code, ns, possibleKey, options);
            }
          }
        });
      });
    });
    return {
      res: found,
      usedKey,
      exactUsedKey,
      usedLng,
      usedNS
    };
  }
  isValidLookup(res) {
    return res !== void 0 && !(!this.options.returnNull && res === null) && !(!this.options.returnEmptyString && res === "");
  }
  getResource(code, ns, key) {
    let options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
    if (this.i18nFormat && this.i18nFormat.getResource)
      return this.i18nFormat.getResource(code, ns, key, options);
    return this.resourceStore.getResource(code, ns, key, options);
  }
  static hasDefaultValue(options) {
    const prefix = "defaultValue";
    for (const option in options) {
      if (Object.prototype.hasOwnProperty.call(options, option) && prefix === option.substring(0, prefix.length) && void 0 !== options[option]) {
        return true;
      }
    }
    return false;
  }
};
function capitalize(string) {
  return string.charAt(0).toUpperCase() + string.slice(1);
}
var LanguageUtil = class {
  constructor(options) {
    this.options = options;
    this.supportedLngs = this.options.supportedLngs || false;
    this.logger = baseLogger.create("languageUtils");
  }
  getScriptPartFromCode(code) {
    code = getCleanedCode(code);
    if (!code || code.indexOf("-") < 0)
      return null;
    const p = code.split("-");
    if (p.length === 2)
      return null;
    p.pop();
    if (p[p.length - 1].toLowerCase() === "x")
      return null;
    return this.formatLanguageCode(p.join("-"));
  }
  getLanguagePartFromCode(code) {
    code = getCleanedCode(code);
    if (!code || code.indexOf("-") < 0)
      return code;
    const p = code.split("-");
    return this.formatLanguageCode(p[0]);
  }
  formatLanguageCode(code) {
    if (typeof code === "string" && code.indexOf("-") > -1) {
      const specialCases = ["hans", "hant", "latn", "cyrl", "cans", "mong", "arab"];
      let p = code.split("-");
      if (this.options.lowerCaseLng) {
        p = p.map((part) => part.toLowerCase());
      } else if (p.length === 2) {
        p[0] = p[0].toLowerCase();
        p[1] = p[1].toUpperCase();
        if (specialCases.indexOf(p[1].toLowerCase()) > -1)
          p[1] = capitalize(p[1].toLowerCase());
      } else if (p.length === 3) {
        p[0] = p[0].toLowerCase();
        if (p[1].length === 2)
          p[1] = p[1].toUpperCase();
        if (p[0] !== "sgn" && p[2].length === 2)
          p[2] = p[2].toUpperCase();
        if (specialCases.indexOf(p[1].toLowerCase()) > -1)
          p[1] = capitalize(p[1].toLowerCase());
        if (specialCases.indexOf(p[2].toLowerCase()) > -1)
          p[2] = capitalize(p[2].toLowerCase());
      }
      return p.join("-");
    }
    return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
  }
  isSupportedCode(code) {
    if (this.options.load === "languageOnly" || this.options.nonExplicitSupportedLngs) {
      code = this.getLanguagePartFromCode(code);
    }
    return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.indexOf(code) > -1;
  }
  getBestMatchFromCodes(codes) {
    if (!codes)
      return null;
    let found;
    codes.forEach((code) => {
      if (found)
        return;
      const cleanedLng = this.formatLanguageCode(code);
      if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng))
        found = cleanedLng;
    });
    if (!found && this.options.supportedLngs) {
      codes.forEach((code) => {
        if (found)
          return;
        const lngOnly = this.getLanguagePartFromCode(code);
        if (this.isSupportedCode(lngOnly))
          return found = lngOnly;
        found = this.options.supportedLngs.find((supportedLng) => {
          if (supportedLng === lngOnly)
            return supportedLng;
          if (supportedLng.indexOf("-") < 0 && lngOnly.indexOf("-") < 0)
            return;
          if (supportedLng.indexOf(lngOnly) === 0)
            return supportedLng;
        });
      });
    }
    if (!found)
      found = this.getFallbackCodes(this.options.fallbackLng)[0];
    return found;
  }
  getFallbackCodes(fallbacks, code) {
    if (!fallbacks)
      return [];
    if (typeof fallbacks === "function")
      fallbacks = fallbacks(code);
    if (typeof fallbacks === "string")
      fallbacks = [fallbacks];
    if (Object.prototype.toString.apply(fallbacks) === "[object Array]")
      return fallbacks;
    if (!code)
      return fallbacks.default || [];
    let found = fallbacks[code];
    if (!found)
      found = fallbacks[this.getScriptPartFromCode(code)];
    if (!found)
      found = fallbacks[this.formatLanguageCode(code)];
    if (!found)
      found = fallbacks[this.getLanguagePartFromCode(code)];
    if (!found)
      found = fallbacks.default;
    return found || [];
  }
  toResolveHierarchy(code, fallbackCode) {
    const fallbackCodes = this.getFallbackCodes(fallbackCode || this.options.fallbackLng || [], code);
    const codes = [];
    const addCode = (c) => {
      if (!c)
        return;
      if (this.isSupportedCode(c)) {
        codes.push(c);
      } else {
        this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
      }
    };
    if (typeof code === "string" && (code.indexOf("-") > -1 || code.indexOf("_") > -1)) {
      if (this.options.load !== "languageOnly")
        addCode(this.formatLanguageCode(code));
      if (this.options.load !== "languageOnly" && this.options.load !== "currentOnly")
        addCode(this.getScriptPartFromCode(code));
      if (this.options.load !== "currentOnly")
        addCode(this.getLanguagePartFromCode(code));
    } else if (typeof code === "string") {
      addCode(this.formatLanguageCode(code));
    }
    fallbackCodes.forEach((fc) => {
      if (codes.indexOf(fc) < 0)
        addCode(this.formatLanguageCode(fc));
    });
    return codes;
  }
};
var sets = [{
  lngs: ["ach", "ak", "am", "arn", "br", "fil", "gun", "ln", "mfe", "mg", "mi", "oc", "pt", "pt-BR", "tg", "tl", "ti", "tr", "uz", "wa"],
  nr: [1, 2],
  fc: 1
}, {
  lngs: ["af", "an", "ast", "az", "bg", "bn", "ca", "da", "de", "dev", "el", "en", "eo", "es", "et", "eu", "fi", "fo", "fur", "fy", "gl", "gu", "ha", "hi", "hu", "hy", "ia", "it", "kk", "kn", "ku", "lb", "mai", "ml", "mn", "mr", "nah", "nap", "nb", "ne", "nl", "nn", "no", "nso", "pa", "pap", "pms", "ps", "pt-PT", "rm", "sco", "se", "si", "so", "son", "sq", "sv", "sw", "ta", "te", "tk", "ur", "yo"],
  nr: [1, 2],
  fc: 2
}, {
  lngs: ["ay", "bo", "cgg", "fa", "ht", "id", "ja", "jbo", "ka", "km", "ko", "ky", "lo", "ms", "sah", "su", "th", "tt", "ug", "vi", "wo", "zh"],
  nr: [1],
  fc: 3
}, {
  lngs: ["be", "bs", "cnr", "dz", "hr", "ru", "sr", "uk"],
  nr: [1, 2, 5],
  fc: 4
}, {
  lngs: ["ar"],
  nr: [0, 1, 2, 3, 11, 100],
  fc: 5
}, {
  lngs: ["cs", "sk"],
  nr: [1, 2, 5],
  fc: 6
}, {
  lngs: ["csb", "pl"],
  nr: [1, 2, 5],
  fc: 7
}, {
  lngs: ["cy"],
  nr: [1, 2, 3, 8],
  fc: 8
}, {
  lngs: ["fr"],
  nr: [1, 2],
  fc: 9
}, {
  lngs: ["ga"],
  nr: [1, 2, 3, 7, 11],
  fc: 10
}, {
  lngs: ["gd"],
  nr: [1, 2, 3, 20],
  fc: 11
}, {
  lngs: ["is"],
  nr: [1, 2],
  fc: 12
}, {
  lngs: ["jv"],
  nr: [0, 1],
  fc: 13
}, {
  lngs: ["kw"],
  nr: [1, 2, 3, 4],
  fc: 14
}, {
  lngs: ["lt"],
  nr: [1, 2, 10],
  fc: 15
}, {
  lngs: ["lv"],
  nr: [1, 2, 0],
  fc: 16
}, {
  lngs: ["mk"],
  nr: [1, 2],
  fc: 17
}, {
  lngs: ["mnk"],
  nr: [0, 1, 2],
  fc: 18
}, {
  lngs: ["mt"],
  nr: [1, 2, 11, 20],
  fc: 19
}, {
  lngs: ["or"],
  nr: [2, 1],
  fc: 2
}, {
  lngs: ["ro"],
  nr: [1, 2, 20],
  fc: 20
}, {
  lngs: ["sl"],
  nr: [5, 1, 2, 3],
  fc: 21
}, {
  lngs: ["he", "iw"],
  nr: [1, 2, 20, 21],
  fc: 22
}];
var _rulesPluralsTypes = {
  1: function(n) {
    return Number(n > 1);
  },
  2: function(n) {
    return Number(n != 1);
  },
  3: function(n) {
    return 0;
  },
  4: function(n) {
    return Number(n % 10 == 1 && n % 100 != 11 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2);
  },
  5: function(n) {
    return Number(n == 0 ? 0 : n == 1 ? 1 : n == 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5);
  },
  6: function(n) {
    return Number(n == 1 ? 0 : n >= 2 && n <= 4 ? 1 : 2);
  },
  7: function(n) {
    return Number(n == 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2);
  },
  8: function(n) {
    return Number(n == 1 ? 0 : n == 2 ? 1 : n != 8 && n != 11 ? 2 : 3);
  },
  9: function(n) {
    return Number(n >= 2);
  },
  10: function(n) {
    return Number(n == 1 ? 0 : n == 2 ? 1 : n < 7 ? 2 : n < 11 ? 3 : 4);
  },
  11: function(n) {
    return Number(n == 1 || n == 11 ? 0 : n == 2 || n == 12 ? 1 : n > 2 && n < 20 ? 2 : 3);
  },
  12: function(n) {
    return Number(n % 10 != 1 || n % 100 == 11);
  },
  13: function(n) {
    return Number(n !== 0);
  },
  14: function(n) {
    return Number(n == 1 ? 0 : n == 2 ? 1 : n == 3 ? 2 : 3);
  },
  15: function(n) {
    return Number(n % 10 == 1 && n % 100 != 11 ? 0 : n % 10 >= 2 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2);
  },
  16: function(n) {
    return Number(n % 10 == 1 && n % 100 != 11 ? 0 : n !== 0 ? 1 : 2);
  },
  17: function(n) {
    return Number(n == 1 || n % 10 == 1 && n % 100 != 11 ? 0 : 1);
  },
  18: function(n) {
    return Number(n == 0 ? 0 : n == 1 ? 1 : 2);
  },
  19: function(n) {
    return Number(n == 1 ? 0 : n == 0 || n % 100 > 1 && n % 100 < 11 ? 1 : n % 100 > 10 && n % 100 < 20 ? 2 : 3);
  },
  20: function(n) {
    return Number(n == 1 ? 0 : n == 0 || n % 100 > 0 && n % 100 < 20 ? 1 : 2);
  },
  21: function(n) {
    return Number(n % 100 == 1 ? 1 : n % 100 == 2 ? 2 : n % 100 == 3 || n % 100 == 4 ? 3 : 0);
  },
  22: function(n) {
    return Number(n == 1 ? 0 : n == 2 ? 1 : (n < 0 || n > 10) && n % 10 == 0 ? 2 : 3);
  }
};
var nonIntlVersions = ["v1", "v2", "v3"];
var intlVersions = ["v4"];
var suffixesOrder = {
  zero: 0,
  one: 1,
  two: 2,
  few: 3,
  many: 4,
  other: 5
};
function createRules() {
  const rules = {};
  sets.forEach((set) => {
    set.lngs.forEach((l) => {
      rules[l] = {
        numbers: set.nr,
        plurals: _rulesPluralsTypes[set.fc]
      };
    });
  });
  return rules;
}
var PluralResolver = class {
  constructor(languageUtils) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    this.languageUtils = languageUtils;
    this.options = options;
    this.logger = baseLogger.create("pluralResolver");
    if ((!this.options.compatibilityJSON || intlVersions.includes(this.options.compatibilityJSON)) && (typeof Intl === "undefined" || !Intl.PluralRules)) {
      this.options.compatibilityJSON = "v3";
      this.logger.error("Your environment seems not to be Intl API compatible, use an Intl.PluralRules polyfill. Will fallback to the compatibilityJSON v3 format handling.");
    }
    this.rules = createRules();
  }
  addRule(lng, obj) {
    this.rules[lng] = obj;
  }
  getRule(code) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    if (this.shouldUseIntlApi()) {
      try {
        return new Intl.PluralRules(getCleanedCode(code), {
          type: options.ordinal ? "ordinal" : "cardinal"
        });
      } catch (e) {
        return;
      }
    }
    return this.rules[code] || this.rules[this.languageUtils.getLanguagePartFromCode(code)];
  }
  needsPlural(code) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    const rule = this.getRule(code, options);
    if (this.shouldUseIntlApi()) {
      return rule && rule.resolvedOptions().pluralCategories.length > 1;
    }
    return rule && rule.numbers.length > 1;
  }
  getPluralFormsOfKey(code, key) {
    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
    return this.getSuffixes(code, options).map((suffix) => `${key}${suffix}`);
  }
  getSuffixes(code) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    const rule = this.getRule(code, options);
    if (!rule) {
      return [];
    }
    if (this.shouldUseIntlApi()) {
      return rule.resolvedOptions().pluralCategories.sort((pluralCategory1, pluralCategory2) => suffixesOrder[pluralCategory1] - suffixesOrder[pluralCategory2]).map((pluralCategory) => `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ""}${pluralCategory}`);
    }
    return rule.numbers.map((number) => this.getSuffix(code, number, options));
  }
  getSuffix(code, count) {
    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
    const rule = this.getRule(code, options);
    if (rule) {
      if (this.shouldUseIntlApi()) {
        return `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ""}${rule.select(count)}`;
      }
      return this.getSuffixRetroCompatible(rule, count);
    }
    this.logger.warn(`no plural rule found for: ${code}`);
    return "";
  }
  getSuffixRetroCompatible(rule, count) {
    const idx = rule.noAbs ? rule.plurals(count) : rule.plurals(Math.abs(count));
    let suffix = rule.numbers[idx];
    if (this.options.simplifyPluralSuffix && rule.numbers.length === 2 && rule.numbers[0] === 1) {
      if (suffix === 2) {
        suffix = "plural";
      } else if (suffix === 1) {
        suffix = "";
      }
    }
    const returnSuffix = () => this.options.prepend && suffix.toString() ? this.options.prepend + suffix.toString() : suffix.toString();
    if (this.options.compatibilityJSON === "v1") {
      if (suffix === 1)
        return "";
      if (typeof suffix === "number")
        return `_plural_${suffix.toString()}`;
      return returnSuffix();
    } else if (this.options.compatibilityJSON === "v2") {
      return returnSuffix();
    } else if (this.options.simplifyPluralSuffix && rule.numbers.length === 2 && rule.numbers[0] === 1) {
      return returnSuffix();
    }
    return this.options.prepend && idx.toString() ? this.options.prepend + idx.toString() : idx.toString();
  }
  shouldUseIntlApi() {
    return !nonIntlVersions.includes(this.options.compatibilityJSON);
  }
};
function deepFindWithDefaults(data, defaultData, key) {
  let keySeparator = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : ".";
  let ignoreJSONStructure = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true;
  let path = getPathWithDefaults(data, defaultData, key);
  if (!path && ignoreJSONStructure && typeof key === "string") {
    path = deepFind(data, key, keySeparator);
    if (path === void 0)
      path = deepFind(defaultData, key, keySeparator);
  }
  return path;
}
var Interpolator = class {
  constructor() {
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    this.logger = baseLogger.create("interpolator");
    this.options = options;
    this.format = options.interpolation && options.interpolation.format || ((value) => value);
    this.init(options);
  }
  init() {
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    if (!options.interpolation)
      options.interpolation = {
        escapeValue: true
      };
    const iOpts = options.interpolation;
    this.escape = iOpts.escape !== void 0 ? iOpts.escape : escape;
    this.escapeValue = iOpts.escapeValue !== void 0 ? iOpts.escapeValue : true;
    this.useRawValueToEscape = iOpts.useRawValueToEscape !== void 0 ? iOpts.useRawValueToEscape : false;
    this.prefix = iOpts.prefix ? regexEscape(iOpts.prefix) : iOpts.prefixEscaped || "{{";
    this.suffix = iOpts.suffix ? regexEscape(iOpts.suffix) : iOpts.suffixEscaped || "}}";
    this.formatSeparator = iOpts.formatSeparator ? iOpts.formatSeparator : iOpts.formatSeparator || ",";
    this.unescapePrefix = iOpts.unescapeSuffix ? "" : iOpts.unescapePrefix || "-";
    this.unescapeSuffix = this.unescapePrefix ? "" : iOpts.unescapeSuffix || "";
    this.nestingPrefix = iOpts.nestingPrefix ? regexEscape(iOpts.nestingPrefix) : iOpts.nestingPrefixEscaped || regexEscape("$t(");
    this.nestingSuffix = iOpts.nestingSuffix ? regexEscape(iOpts.nestingSuffix) : iOpts.nestingSuffixEscaped || regexEscape(")");
    this.nestingOptionsSeparator = iOpts.nestingOptionsSeparator ? iOpts.nestingOptionsSeparator : iOpts.nestingOptionsSeparator || ",";
    this.maxReplaces = iOpts.maxReplaces ? iOpts.maxReplaces : 1e3;
    this.alwaysFormat = iOpts.alwaysFormat !== void 0 ? iOpts.alwaysFormat : false;
    this.resetRegExp();
  }
  reset() {
    if (this.options)
      this.init(this.options);
  }
  resetRegExp() {
    const regexpStr = `${this.prefix}(.+?)${this.suffix}`;
    this.regexp = new RegExp(regexpStr, "g");
    const regexpUnescapeStr = `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`;
    this.regexpUnescape = new RegExp(regexpUnescapeStr, "g");
    const nestingRegexpStr = `${this.nestingPrefix}(.+?)${this.nestingSuffix}`;
    this.nestingRegexp = new RegExp(nestingRegexpStr, "g");
  }
  interpolate(str, data, lng, options) {
    let match;
    let value;
    let replaces;
    const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
    function regexSafe(val) {
      return val.replace(/\$/g, "$$$$");
    }
    const handleFormat = (key) => {
      if (key.indexOf(this.formatSeparator) < 0) {
        const path = deepFindWithDefaults(data, defaultData, key, this.options.keySeparator, this.options.ignoreJSONStructure);
        return this.alwaysFormat ? this.format(path, void 0, lng, {
          ...options,
          ...data,
          interpolationkey: key
        }) : path;
      }
      const p = key.split(this.formatSeparator);
      const k = p.shift().trim();
      const f = p.join(this.formatSeparator).trim();
      return this.format(deepFindWithDefaults(data, defaultData, k, this.options.keySeparator, this.options.ignoreJSONStructure), f, lng, {
        ...options,
        ...data,
        interpolationkey: k
      });
    };
    this.resetRegExp();
    const missingInterpolationHandler = options && options.missingInterpolationHandler || this.options.missingInterpolationHandler;
    const skipOnVariables = options && options.interpolation && options.interpolation.skipOnVariables !== void 0 ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables;
    const todos = [{
      regex: this.regexpUnescape,
      safeValue: (val) => regexSafe(val)
    }, {
      regex: this.regexp,
      safeValue: (val) => this.escapeValue ? regexSafe(this.escape(val)) : regexSafe(val)
    }];
    todos.forEach((todo) => {
      replaces = 0;
      while (match = todo.regex.exec(str)) {
        const matchedVar = match[1].trim();
        value = handleFormat(matchedVar);
        if (value === void 0) {
          if (typeof missingInterpolationHandler === "function") {
            const temp = missingInterpolationHandler(str, match, options);
            value = typeof temp === "string" ? temp : "";
          } else if (options && Object.prototype.hasOwnProperty.call(options, matchedVar)) {
            value = "";
          } else if (skipOnVariables) {
            value = match[0];
            continue;
          } else {
            this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
            value = "";
          }
        } else if (typeof value !== "string" && !this.useRawValueToEscape) {
          value = makeString(value);
        }
        const safeValue = todo.safeValue(value);
        str = str.replace(match[0], safeValue);
        if (skipOnVariables) {
          todo.regex.lastIndex += value.length;
          todo.regex.lastIndex -= match[0].length;
        } else {
          todo.regex.lastIndex = 0;
        }
        replaces++;
        if (replaces >= this.maxReplaces) {
          break;
        }
      }
    });
    return str;
  }
  nest(str, fc) {
    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
    let match;
    let value;
    let clonedOptions;
    function handleHasOptions(key, inheritedOptions) {
      const sep = this.nestingOptionsSeparator;
      if (key.indexOf(sep) < 0)
        return key;
      const c = key.split(new RegExp(`${sep}[ ]*{`));
      let optionsString = `{${c[1]}`;
      key = c[0];
      optionsString = this.interpolate(optionsString, clonedOptions);
      const matchedSingleQuotes = optionsString.match(/'/g);
      const matchedDoubleQuotes = optionsString.match(/"/g);
      if (matchedSingleQuotes && matchedSingleQuotes.length % 2 === 0 && !matchedDoubleQuotes || matchedDoubleQuotes.length % 2 !== 0) {
        optionsString = optionsString.replace(/'/g, '"');
      }
      try {
        clonedOptions = JSON.parse(optionsString);
        if (inheritedOptions)
          clonedOptions = {
            ...inheritedOptions,
            ...clonedOptions
          };
      } catch (e) {
        this.logger.warn(`failed parsing options string in nesting for key ${key}`, e);
        return `${key}${sep}${optionsString}`;
      }
      delete clonedOptions.defaultValue;
      return key;
    }
    while (match = this.nestingRegexp.exec(str)) {
      let formatters = [];
      clonedOptions = {
        ...options
      };
      clonedOptions = clonedOptions.replace && typeof clonedOptions.replace !== "string" ? clonedOptions.replace : clonedOptions;
      clonedOptions.applyPostProcessor = false;
      delete clonedOptions.defaultValue;
      let doReduce = false;
      if (match[0].indexOf(this.formatSeparator) !== -1 && !/{.*}/.test(match[1])) {
        const r = match[1].split(this.formatSeparator).map((elem) => elem.trim());
        match[1] = r.shift();
        formatters = r;
        doReduce = true;
      }
      value = fc(handleHasOptions.call(this, match[1].trim(), clonedOptions), clonedOptions);
      if (value && match[0] === str && typeof value !== "string")
        return value;
      if (typeof value !== "string")
        value = makeString(value);
      if (!value) {
        this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);
        value = "";
      }
      if (doReduce) {
        value = formatters.reduce((v, f) => this.format(v, f, options.lng, {
          ...options,
          interpolationkey: match[1].trim()
        }), value.trim());
      }
      str = str.replace(match[0], value);
      this.regexp.lastIndex = 0;
    }
    return str;
  }
};
function parseFormatStr(formatStr) {
  let formatName = formatStr.toLowerCase().trim();
  const formatOptions = {};
  if (formatStr.indexOf("(") > -1) {
    const p = formatStr.split("(");
    formatName = p[0].toLowerCase().trim();
    const optStr = p[1].substring(0, p[1].length - 1);
    if (formatName === "currency" && optStr.indexOf(":") < 0) {
      if (!formatOptions.currency)
        formatOptions.currency = optStr.trim();
    } else if (formatName === "relativetime" && optStr.indexOf(":") < 0) {
      if (!formatOptions.range)
        formatOptions.range = optStr.trim();
    } else {
      const opts = optStr.split(";");
      opts.forEach((opt) => {
        if (!opt)
          return;
        const [key, ...rest] = opt.split(":");
        const val = rest.join(":").trim().replace(/^'+|'+$/g, "");
        if (!formatOptions[key.trim()])
          formatOptions[key.trim()] = val;
        if (val === "false")
          formatOptions[key.trim()] = false;
        if (val === "true")
          formatOptions[key.trim()] = true;
        if (!isNaN(val))
          formatOptions[key.trim()] = parseInt(val, 10);
      });
    }
  }
  return {
    formatName,
    formatOptions
  };
}
function createCachedFormatter(fn) {
  const cache = {};
  return function invokeFormatter(val, lng, options) {
    const key = lng + JSON.stringify(options);
    let formatter = cache[key];
    if (!formatter) {
      formatter = fn(getCleanedCode(lng), options);
      cache[key] = formatter;
    }
    return formatter(val);
  };
}
var Formatter = class {
  constructor() {
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    this.logger = baseLogger.create("formatter");
    this.options = options;
    this.formats = {
      number: createCachedFormatter((lng, opt) => {
        const formatter = new Intl.NumberFormat(lng, {
          ...opt
        });
        return (val) => formatter.format(val);
      }),
      currency: createCachedFormatter((lng, opt) => {
        const formatter = new Intl.NumberFormat(lng, {
          ...opt,
          style: "currency"
        });
        return (val) => formatter.format(val);
      }),
      datetime: createCachedFormatter((lng, opt) => {
        const formatter = new Intl.DateTimeFormat(lng, {
          ...opt
        });
        return (val) => formatter.format(val);
      }),
      relativetime: createCachedFormatter((lng, opt) => {
        const formatter = new Intl.RelativeTimeFormat(lng, {
          ...opt
        });
        return (val) => formatter.format(val, opt.range || "day");
      }),
      list: createCachedFormatter((lng, opt) => {
        const formatter = new Intl.ListFormat(lng, {
          ...opt
        });
        return (val) => formatter.format(val);
      })
    };
    this.init(options);
  }
  init(services) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
      interpolation: {}
    };
    const iOpts = options.interpolation;
    this.formatSeparator = iOpts.formatSeparator ? iOpts.formatSeparator : iOpts.formatSeparator || ",";
  }
  add(name, fc) {
    this.formats[name.toLowerCase().trim()] = fc;
  }
  addCached(name, fc) {
    this.formats[name.toLowerCase().trim()] = createCachedFormatter(fc);
  }
  format(value, format, lng) {
    let options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
    const formats = format.split(this.formatSeparator);
    const result = formats.reduce((mem, f) => {
      const {
        formatName,
        formatOptions
      } = parseFormatStr(f);
      if (this.formats[formatName]) {
        let formatted = mem;
        try {
          const valOptions = options && options.formatParams && options.formatParams[options.interpolationkey] || {};
          const l = valOptions.locale || valOptions.lng || options.locale || options.lng || lng;
          formatted = this.formats[formatName](mem, l, {
            ...formatOptions,
            ...options,
            ...valOptions
          });
        } catch (error) {
          this.logger.warn(error);
        }
        return formatted;
      } else {
        this.logger.warn(`there was no format function for ${formatName}`);
      }
      return mem;
    }, value);
    return result;
  }
};
function removePending(q, name) {
  if (q.pending[name] !== void 0) {
    delete q.pending[name];
    q.pendingCount--;
  }
}
var Connector = class extends EventEmitter {
  constructor(backend, store, services) {
    let options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
    super();
    this.backend = backend;
    this.store = store;
    this.services = services;
    this.languageUtils = services.languageUtils;
    this.options = options;
    this.logger = baseLogger.create("backendConnector");
    this.waitingReads = [];
    this.maxParallelReads = options.maxParallelReads || 10;
    this.readingCalls = 0;
    this.maxRetries = options.maxRetries >= 0 ? options.maxRetries : 5;
    this.retryTimeout = options.retryTimeout >= 1 ? options.retryTimeout : 350;
    this.state = {};
    this.queue = [];
    if (this.backend && this.backend.init) {
      this.backend.init(services, options.backend, options);
    }
  }
  queueLoad(languages, namespaces, options, callback) {
    const toLoad = {};
    const pending = {};
    const toLoadLanguages = {};
    const toLoadNamespaces = {};
    languages.forEach((lng) => {
      let hasAllNamespaces = true;
      namespaces.forEach((ns) => {
        const name = `${lng}|${ns}`;
        if (!options.reload && this.store.hasResourceBundle(lng, ns)) {
          this.state[name] = 2;
        } else if (this.state[name] < 0)
          ;
        else if (this.state[name] === 1) {
          if (pending[name] === void 0)
            pending[name] = true;
        } else {
          this.state[name] = 1;
          hasAllNamespaces = false;
          if (pending[name] === void 0)
            pending[name] = true;
          if (toLoad[name] === void 0)
            toLoad[name] = true;
          if (toLoadNamespaces[ns] === void 0)
            toLoadNamespaces[ns] = true;
        }
      });
      if (!hasAllNamespaces)
        toLoadLanguages[lng] = true;
    });
    if (Object.keys(toLoad).length || Object.keys(pending).length) {
      this.queue.push({
        pending,
        pendingCount: Object.keys(pending).length,
        loaded: {},
        errors: [],
        callback
      });
    }
    return {
      toLoad: Object.keys(toLoad),
      pending: Object.keys(pending),
      toLoadLanguages: Object.keys(toLoadLanguages),
      toLoadNamespaces: Object.keys(toLoadNamespaces)
    };
  }
  loaded(name, err, data) {
    const s = name.split("|");
    const lng = s[0];
    const ns = s[1];
    if (err)
      this.emit("failedLoading", lng, ns, err);
    if (data) {
      this.store.addResourceBundle(lng, ns, data);
    }
    this.state[name] = err ? -1 : 2;
    const loaded = {};
    this.queue.forEach((q) => {
      pushPath(q.loaded, [lng], ns);
      removePending(q, name);
      if (err)
        q.errors.push(err);
      if (q.pendingCount === 0 && !q.done) {
        Object.keys(q.loaded).forEach((l) => {
          if (!loaded[l])
            loaded[l] = {};
          const loadedKeys = q.loaded[l];
          if (loadedKeys.length) {
            loadedKeys.forEach((n) => {
              if (loaded[l][n] === void 0)
                loaded[l][n] = true;
            });
          }
        });
        q.done = true;
        if (q.errors.length) {
          q.callback(q.errors);
        } else {
          q.callback();
        }
      }
    });
    this.emit("loaded", loaded);
    this.queue = this.queue.filter((q) => !q.done);
  }
  read(lng, ns, fcName) {
    let tried = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
    let wait = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : this.retryTimeout;
    let callback = arguments.length > 5 ? arguments[5] : void 0;
    if (!lng.length)
      return callback(null, {});
    if (this.readingCalls >= this.maxParallelReads) {
      this.waitingReads.push({
        lng,
        ns,
        fcName,
        tried,
        wait,
        callback
      });
      return;
    }
    this.readingCalls++;
    const resolver = (err, data) => {
      this.readingCalls--;
      if (this.waitingReads.length > 0) {
        const next = this.waitingReads.shift();
        this.read(next.lng, next.ns, next.fcName, next.tried, next.wait, next.callback);
      }
      if (err && data && tried < this.maxRetries) {
        setTimeout(() => {
          this.read.call(this, lng, ns, fcName, tried + 1, wait * 2, callback);
        }, wait);
        return;
      }
      callback(err, data);
    };
    const fc = this.backend[fcName].bind(this.backend);
    if (fc.length === 2) {
      try {
        const r = fc(lng, ns);
        if (r && typeof r.then === "function") {
          r.then((data) => resolver(null, data)).catch(resolver);
        } else {
          resolver(null, r);
        }
      } catch (err) {
        resolver(err);
      }
      return;
    }
    return fc(lng, ns, resolver);
  }
  prepareLoading(languages, namespaces) {
    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
    let callback = arguments.length > 3 ? arguments[3] : void 0;
    if (!this.backend) {
      this.logger.warn("No backend was added via i18next.use. Will not load resources.");
      return callback && callback();
    }
    if (typeof languages === "string")
      languages = this.languageUtils.toResolveHierarchy(languages);
    if (typeof namespaces === "string")
      namespaces = [namespaces];
    const toLoad = this.queueLoad(languages, namespaces, options, callback);
    if (!toLoad.toLoad.length) {
      if (!toLoad.pending.length)
        callback();
      return null;
    }
    toLoad.toLoad.forEach((name) => {
      this.loadOne(name);
    });
  }
  load(languages, namespaces, callback) {
    this.prepareLoading(languages, namespaces, {}, callback);
  }
  reload(languages, namespaces, callback) {
    this.prepareLoading(languages, namespaces, {
      reload: true
    }, callback);
  }
  loadOne(name) {
    let prefix = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
    const s = name.split("|");
    const lng = s[0];
    const ns = s[1];
    this.read(lng, ns, "read", void 0, void 0, (err, data) => {
      if (err)
        this.logger.warn(`${prefix}loading namespace ${ns} for language ${lng} failed`, err);
      if (!err && data)
        this.logger.log(`${prefix}loaded namespace ${ns} for language ${lng}`, data);
      this.loaded(name, err, data);
    });
  }
  saveMissing(languages, namespace, key, fallbackValue, isUpdate) {
    let options = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : {};
    let clb = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : () => {
    };
    if (this.services.utils && this.services.utils.hasLoadedNamespace && !this.services.utils.hasLoadedNamespace(namespace)) {
      this.logger.warn(`did not save key "${key}" as the namespace "${namespace}" was not yet loaded`, "This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!");
      return;
    }
    if (key === void 0 || key === null || key === "")
      return;
    if (this.backend && this.backend.create) {
      const opts = {
        ...options,
        isUpdate
      };
      const fc = this.backend.create.bind(this.backend);
      if (fc.length < 6) {
        try {
          let r;
          if (fc.length === 5) {
            r = fc(languages, namespace, key, fallbackValue, opts);
          } else {
            r = fc(languages, namespace, key, fallbackValue);
          }
          if (r && typeof r.then === "function") {
            r.then((data) => clb(null, data)).catch(clb);
          } else {
            clb(null, r);
          }
        } catch (err) {
          clb(err);
        }
      } else {
        fc(languages, namespace, key, fallbackValue, clb, opts);
      }
    }
    if (!languages || !languages[0])
      return;
    this.store.addResource(languages[0], namespace, key, fallbackValue);
  }
};
function get() {
  return {
    debug: false,
    initImmediate: true,
    ns: ["translation"],
    defaultNS: ["translation"],
    fallbackLng: ["dev"],
    fallbackNS: false,
    supportedLngs: false,
    nonExplicitSupportedLngs: false,
    load: "all",
    preload: false,
    simplifyPluralSuffix: true,
    keySeparator: ".",
    nsSeparator: ":",
    pluralSeparator: "_",
    contextSeparator: "_",
    partialBundledLanguages: false,
    saveMissing: false,
    updateMissing: false,
    saveMissingTo: "fallback",
    saveMissingPlurals: true,
    missingKeyHandler: false,
    missingInterpolationHandler: false,
    postProcess: false,
    postProcessPassResolved: false,
    returnNull: false,
    returnEmptyString: true,
    returnObjects: false,
    joinArrays: false,
    returnedObjectHandler: false,
    parseMissingKeyHandler: false,
    appendNamespaceToMissingKey: false,
    appendNamespaceToCIMode: false,
    overloadTranslationOptionHandler: function handle(args) {
      let ret = {};
      if (typeof args[1] === "object")
        ret = args[1];
      if (typeof args[1] === "string")
        ret.defaultValue = args[1];
      if (typeof args[2] === "string")
        ret.tDescription = args[2];
      if (typeof args[2] === "object" || typeof args[3] === "object") {
        const options = args[3] || args[2];
        Object.keys(options).forEach((key) => {
          ret[key] = options[key];
        });
      }
      return ret;
    },
    interpolation: {
      escapeValue: true,
      format: (value, format, lng, options) => value,
      prefix: "{{",
      suffix: "}}",
      formatSeparator: ",",
      unescapePrefix: "-",
      nestingPrefix: "$t(",
      nestingSuffix: ")",
      nestingOptionsSeparator: ",",
      maxReplaces: 1e3,
      skipOnVariables: true
    }
  };
}
function transformOptions(options) {
  if (typeof options.ns === "string")
    options.ns = [options.ns];
  if (typeof options.fallbackLng === "string")
    options.fallbackLng = [options.fallbackLng];
  if (typeof options.fallbackNS === "string")
    options.fallbackNS = [options.fallbackNS];
  if (options.supportedLngs && options.supportedLngs.indexOf("cimode") < 0) {
    options.supportedLngs = options.supportedLngs.concat(["cimode"]);
  }
  return options;
}
function noop() {
}
function bindMemberFunctions(inst) {
  const mems = Object.getOwnPropertyNames(Object.getPrototypeOf(inst));
  mems.forEach((mem) => {
    if (typeof inst[mem] === "function") {
      inst[mem] = inst[mem].bind(inst);
    }
  });
}
var I18n = class _I18n extends EventEmitter {
  constructor() {
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    let callback = arguments.length > 1 ? arguments[1] : void 0;
    super();
    this.options = transformOptions(options);
    this.services = {};
    this.logger = baseLogger;
    this.modules = {
      external: []
    };
    bindMemberFunctions(this);
    if (callback && !this.isInitialized && !options.isClone) {
      if (!this.options.initImmediate) {
        this.init(options, callback);
        return this;
      }
      setTimeout(() => {
        this.init(options, callback);
      }, 0);
    }
  }
  init() {
    var _this = this;
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    let callback = arguments.length > 1 ? arguments[1] : void 0;
    if (typeof options === "function") {
      callback = options;
      options = {};
    }
    if (!options.defaultNS && options.defaultNS !== false && options.ns) {
      if (typeof options.ns === "string") {
        options.defaultNS = options.ns;
      } else if (options.ns.indexOf("translation") < 0) {
        options.defaultNS = options.ns[0];
      }
    }
    const defOpts = get();
    this.options = {
      ...defOpts,
      ...this.options,
      ...transformOptions(options)
    };
    if (this.options.compatibilityAPI !== "v1") {
      this.options.interpolation = {
        ...defOpts.interpolation,
        ...this.options.interpolation
      };
    }
    if (options.keySeparator !== void 0) {
      this.options.userDefinedKeySeparator = options.keySeparator;
    }
    if (options.nsSeparator !== void 0) {
      this.options.userDefinedNsSeparator = options.nsSeparator;
    }
    function createClassOnDemand(ClassOrObject) {
      if (!ClassOrObject)
        return null;
      if (typeof ClassOrObject === "function")
        return new ClassOrObject();
      return ClassOrObject;
    }
    if (!this.options.isClone) {
      if (this.modules.logger) {
        baseLogger.init(createClassOnDemand(this.modules.logger), this.options);
      } else {
        baseLogger.init(null, this.options);
      }
      let formatter;
      if (this.modules.formatter) {
        formatter = this.modules.formatter;
      } else if (typeof Intl !== "undefined") {
        formatter = Formatter;
      }
      const lu = new LanguageUtil(this.options);
      this.store = new ResourceStore(this.options.resources, this.options);
      const s = this.services;
      s.logger = baseLogger;
      s.resourceStore = this.store;
      s.languageUtils = lu;
      s.pluralResolver = new PluralResolver(lu, {
        prepend: this.options.pluralSeparator,
        compatibilityJSON: this.options.compatibilityJSON,
        simplifyPluralSuffix: this.options.simplifyPluralSuffix
      });
      if (formatter && (!this.options.interpolation.format || this.options.interpolation.format === defOpts.interpolation.format)) {
        s.formatter = createClassOnDemand(formatter);
        s.formatter.init(s, this.options);
        this.options.interpolation.format = s.formatter.format.bind(s.formatter);
      }
      s.interpolator = new Interpolator(this.options);
      s.utils = {
        hasLoadedNamespace: this.hasLoadedNamespace.bind(this)
      };
      s.backendConnector = new Connector(createClassOnDemand(this.modules.backend), s.resourceStore, s, this.options);
      s.backendConnector.on("*", function(event) {
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }
        _this.emit(event, ...args);
      });
      if (this.modules.languageDetector) {
        s.languageDetector = createClassOnDemand(this.modules.languageDetector);
        if (s.languageDetector.init)
          s.languageDetector.init(s, this.options.detection, this.options);
      }
      if (this.modules.i18nFormat) {
        s.i18nFormat = createClassOnDemand(this.modules.i18nFormat);
        if (s.i18nFormat.init)
          s.i18nFormat.init(this);
      }
      this.translator = new Translator(this.services, this.options);
      this.translator.on("*", function(event) {
        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
          args[_key2 - 1] = arguments[_key2];
        }
        _this.emit(event, ...args);
      });
      this.modules.external.forEach((m) => {
        if (m.init)
          m.init(this);
      });
    }
    this.format = this.options.interpolation.format;
    if (!callback)
      callback = noop;
    if (this.options.fallbackLng && !this.services.languageDetector && !this.options.lng) {
      const codes = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
      if (codes.length > 0 && codes[0] !== "dev")
        this.options.lng = codes[0];
    }
    if (!this.services.languageDetector && !this.options.lng) {
      this.logger.warn("init: no languageDetector is used and no lng is defined");
    }
    const storeApi = ["getResource", "hasResourceBundle", "getResourceBundle", "getDataByLanguage"];
    storeApi.forEach((fcName) => {
      this[fcName] = function() {
        return _this.store[fcName](...arguments);
      };
    });
    const storeApiChained = ["addResource", "addResources", "addResourceBundle", "removeResourceBundle"];
    storeApiChained.forEach((fcName) => {
      this[fcName] = function() {
        _this.store[fcName](...arguments);
        return _this;
      };
    });
    const deferred = defer();
    const load = () => {
      const finish = (err, t3) => {
        if (this.isInitialized && !this.initializedStoreOnce)
          this.logger.warn("init: i18next is already initialized. You should call init just once!");
        this.isInitialized = true;
        if (!this.options.isClone)
          this.logger.log("initialized", this.options);
        this.emit("initialized", this.options);
        deferred.resolve(t3);
        callback(err, t3);
      };
      if (this.languages && this.options.compatibilityAPI !== "v1" && !this.isInitialized)
        return finish(null, this.t.bind(this));
      this.changeLanguage(this.options.lng, finish);
    };
    if (this.options.resources || !this.options.initImmediate) {
      load();
    } else {
      setTimeout(load, 0);
    }
    return deferred;
  }
  loadResources(language) {
    let callback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
    let usedCallback = callback;
    const usedLng = typeof language === "string" ? language : this.language;
    if (typeof language === "function")
      usedCallback = language;
    if (!this.options.resources || this.options.partialBundledLanguages) {
      if (usedLng && usedLng.toLowerCase() === "cimode")
        return usedCallback();
      const toLoad = [];
      const append = (lng) => {
        if (!lng)
          return;
        const lngs = this.services.languageUtils.toResolveHierarchy(lng);
        lngs.forEach((l) => {
          if (toLoad.indexOf(l) < 0)
            toLoad.push(l);
        });
      };
      if (!usedLng) {
        const fallbacks = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
        fallbacks.forEach((l) => append(l));
      } else {
        append(usedLng);
      }
      if (this.options.preload) {
        this.options.preload.forEach((l) => append(l));
      }
      this.services.backendConnector.load(toLoad, this.options.ns, (e) => {
        if (!e && !this.resolvedLanguage && this.language)
          this.setResolvedLanguage(this.language);
        usedCallback(e);
      });
    } else {
      usedCallback(null);
    }
  }
  reloadResources(lngs, ns, callback) {
    const deferred = defer();
    if (!lngs)
      lngs = this.languages;
    if (!ns)
      ns = this.options.ns;
    if (!callback)
      callback = noop;
    this.services.backendConnector.reload(lngs, ns, (err) => {
      deferred.resolve();
      callback(err);
    });
    return deferred;
  }
  use(module2) {
    if (!module2)
      throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");
    if (!module2.type)
      throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");
    if (module2.type === "backend") {
      this.modules.backend = module2;
    }
    if (module2.type === "logger" || module2.log && module2.warn && module2.error) {
      this.modules.logger = module2;
    }
    if (module2.type === "languageDetector") {
      this.modules.languageDetector = module2;
    }
    if (module2.type === "i18nFormat") {
      this.modules.i18nFormat = module2;
    }
    if (module2.type === "postProcessor") {
      postProcessor.addPostProcessor(module2);
    }
    if (module2.type === "formatter") {
      this.modules.formatter = module2;
    }
    if (module2.type === "3rdParty") {
      this.modules.external.push(module2);
    }
    return this;
  }
  setResolvedLanguage(l) {
    if (!l || !this.languages)
      return;
    if (["cimode", "dev"].indexOf(l) > -1)
      return;
    for (let li = 0; li < this.languages.length; li++) {
      const lngInLngs = this.languages[li];
      if (["cimode", "dev"].indexOf(lngInLngs) > -1)
        continue;
      if (this.store.hasLanguageSomeTranslations(lngInLngs)) {
        this.resolvedLanguage = lngInLngs;
        break;
      }
    }
  }
  changeLanguage(lng, callback) {
    var _this2 = this;
    this.isLanguageChangingTo = lng;
    const deferred = defer();
    this.emit("languageChanging", lng);
    const setLngProps = (l) => {
      this.language = l;
      this.languages = this.services.languageUtils.toResolveHierarchy(l);
      this.resolvedLanguage = void 0;
      this.setResolvedLanguage(l);
    };
    const done = (err, l) => {
      if (l) {
        setLngProps(l);
        this.translator.changeLanguage(l);
        this.isLanguageChangingTo = void 0;
        this.emit("languageChanged", l);
        this.logger.log("languageChanged", l);
      } else {
        this.isLanguageChangingTo = void 0;
      }
      deferred.resolve(function() {
        return _this2.t(...arguments);
      });
      if (callback)
        callback(err, function() {
          return _this2.t(...arguments);
        });
    };
    const setLng = (lngs) => {
      if (!lng && !lngs && this.services.languageDetector)
        lngs = [];
      const l = typeof lngs === "string" ? lngs : this.services.languageUtils.getBestMatchFromCodes(lngs);
      if (l) {
        if (!this.language) {
          setLngProps(l);
        }
        if (!this.translator.language)
          this.translator.changeLanguage(l);
        if (this.services.languageDetector && this.services.languageDetector.cacheUserLanguage)
          this.services.languageDetector.cacheUserLanguage(l);
      }
      this.loadResources(l, (err) => {
        done(err, l);
      });
    };
    if (!lng && this.services.languageDetector && !this.services.languageDetector.async) {
      setLng(this.services.languageDetector.detect());
    } else if (!lng && this.services.languageDetector && this.services.languageDetector.async) {
      if (this.services.languageDetector.detect.length === 0) {
        this.services.languageDetector.detect().then(setLng);
      } else {
        this.services.languageDetector.detect(setLng);
      }
    } else {
      setLng(lng);
    }
    return deferred;
  }
  getFixedT(lng, ns, keyPrefix) {
    var _this3 = this;
    const fixedT = function(key, opts) {
      let options;
      if (typeof opts !== "object") {
        for (var _len3 = arguments.length, rest = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
          rest[_key3 - 2] = arguments[_key3];
        }
        options = _this3.options.overloadTranslationOptionHandler([key, opts].concat(rest));
      } else {
        options = {
          ...opts
        };
      }
      options.lng = options.lng || fixedT.lng;
      options.lngs = options.lngs || fixedT.lngs;
      options.ns = options.ns || fixedT.ns;
      options.keyPrefix = options.keyPrefix || keyPrefix || fixedT.keyPrefix;
      const keySeparator = _this3.options.keySeparator || ".";
      let resultKey;
      if (options.keyPrefix && Array.isArray(key)) {
        resultKey = key.map((k) => `${options.keyPrefix}${keySeparator}${k}`);
      } else {
        resultKey = options.keyPrefix ? `${options.keyPrefix}${keySeparator}${key}` : key;
      }
      return _this3.t(resultKey, options);
    };
    if (typeof lng === "string") {
      fixedT.lng = lng;
    } else {
      fixedT.lngs = lng;
    }
    fixedT.ns = ns;
    fixedT.keyPrefix = keyPrefix;
    return fixedT;
  }
  t() {
    return this.translator && this.translator.translate(...arguments);
  }
  exists() {
    return this.translator && this.translator.exists(...arguments);
  }
  setDefaultNamespace(ns) {
    this.options.defaultNS = ns;
  }
  hasLoadedNamespace(ns) {
    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    if (!this.isInitialized) {
      this.logger.warn("hasLoadedNamespace: i18next was not initialized", this.languages);
      return false;
    }
    if (!this.languages || !this.languages.length) {
      this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty", this.languages);
      return false;
    }
    const lng = options.lng || this.resolvedLanguage || this.languages[0];
    const fallbackLng = this.options ? this.options.fallbackLng : false;
    const lastLng = this.languages[this.languages.length - 1];
    if (lng.toLowerCase() === "cimode")
      return true;
    const loadNotPending = (l, n) => {
      const loadState = this.services.backendConnector.state[`${l}|${n}`];
      return loadState === -1 || loadState === 2;
    };
    if (options.precheck) {
      const preResult = options.precheck(this, loadNotPending);
      if (preResult !== void 0)
        return preResult;
    }
    if (this.hasResourceBundle(lng, ns))
      return true;
    if (!this.services.backendConnector.backend || this.options.resources && !this.options.partialBundledLanguages)
      return true;
    if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns)))
      return true;
    return false;
  }
  loadNamespaces(ns, callback) {
    const deferred = defer();
    if (!this.options.ns) {
      if (callback)
        callback();
      return Promise.resolve();
    }
    if (typeof ns === "string")
      ns = [ns];
    ns.forEach((n) => {
      if (this.options.ns.indexOf(n) < 0)
        this.options.ns.push(n);
    });
    this.loadResources((err) => {
      deferred.resolve();
      if (callback)
        callback(err);
    });
    return deferred;
  }
  loadLanguages(lngs, callback) {
    const deferred = defer();
    if (typeof lngs === "string")
      lngs = [lngs];
    const preloaded = this.options.preload || [];
    const newLngs = lngs.filter((lng) => preloaded.indexOf(lng) < 0);
    if (!newLngs.length) {
      if (callback)
        callback();
      return Promise.resolve();
    }
    this.options.preload = preloaded.concat(newLngs);
    this.loadResources((err) => {
      deferred.resolve();
      if (callback)
        callback(err);
    });
    return deferred;
  }
  dir(lng) {
    if (!lng)
      lng = this.resolvedLanguage || (this.languages && this.languages.length > 0 ? this.languages[0] : this.language);
    if (!lng)
      return "rtl";
    const rtlLngs = ["ar", "shu", "sqr", "ssh", "xaa", "yhd", "yud", "aao", "abh", "abv", "acm", "acq", "acw", "acx", "acy", "adf", "ads", "aeb", "aec", "afb", "ajp", "apc", "apd", "arb", "arq", "ars", "ary", "arz", "auz", "avl", "ayh", "ayl", "ayn", "ayp", "bbz", "pga", "he", "iw", "ps", "pbt", "pbu", "pst", "prp", "prd", "ug", "ur", "ydd", "yds", "yih", "ji", "yi", "hbo", "men", "xmn", "fa", "jpr", "peo", "pes", "prs", "dv", "sam", "ckb"];
    const languageUtils = this.services && this.services.languageUtils || new LanguageUtil(get());
    return rtlLngs.indexOf(languageUtils.getLanguagePartFromCode(lng)) > -1 || lng.toLowerCase().indexOf("-arab") > 1 ? "rtl" : "ltr";
  }
  static createInstance() {
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    let callback = arguments.length > 1 ? arguments[1] : void 0;
    return new _I18n(options, callback);
  }
  cloneInstance() {
    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
    let callback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
    const forkResourceStore = options.forkResourceStore;
    if (forkResourceStore)
      delete options.forkResourceStore;
    const mergedOptions = {
      ...this.options,
      ...options,
      ...{
        isClone: true
      }
    };
    const clone = new _I18n(mergedOptions);
    if (options.debug !== void 0 || options.prefix !== void 0) {
      clone.logger = clone.logger.clone(options);
    }
    const membersToCopy = ["store", "services", "language"];
    membersToCopy.forEach((m) => {
      clone[m] = this[m];
    });
    clone.services = {
      ...this.services
    };
    clone.services.utils = {
      hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
    };
    if (forkResourceStore) {
      clone.store = new ResourceStore(this.store.data, mergedOptions);
      clone.services.resourceStore = clone.store;
    }
    clone.translator = new Translator(clone.services, mergedOptions);
    clone.translator.on("*", function(event) {
      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
        args[_key4 - 1] = arguments[_key4];
      }
      clone.emit(event, ...args);
    });
    clone.init(mergedOptions, callback);
    clone.translator.options = mergedOptions;
    clone.translator.backendConnector.services.utils = {
      hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
    };
    return clone;
  }
  toJSON() {
    return {
      options: this.options,
      store: this.store,
      language: this.language,
      languages: this.languages,
      resolvedLanguage: this.resolvedLanguage
    };
  }
};
var instance = I18n.createInstance();
instance.createInstance = I18n.createInstance;
var createInstance = instance.createInstance;
var dir = instance.dir;
var init = instance.init;
var loadResources = instance.loadResources;
var reloadResources = instance.reloadResources;
var use = instance.use;
var changeLanguage = instance.changeLanguage;
var getFixedT = instance.getFixedT;
var t = instance.t;
var exists = instance.exists;
var setDefaultNamespace = instance.setDefaultNamespace;
var hasLoadedNamespace = instance.hasLoadedNamespace;
var loadNamespaces = instance.loadNamespaces;
var loadLanguages = instance.loadLanguages;

// src/i18n/zh/index.ts
var zh = {
  validator: "\u9A8C\u8BC1\u65B9\u5F0F",
  strategy: "\u7B56\u7565",
  cancel: "\u53D6\u6D88",
  apply: "\u5E94\u7528",
  feature: {
    ["alias" /* Alias */]: {
      name: "\u522B\u540DAlias",
      desc: "\u4FEE\u6539\u5143\u6570\u636E\uFF08frontmatter\uFF09\u7F13\u5B58\u4E2D\u7684\u522B\u540D\uFF0C\u4E0D\u5F71\u54CD\u5B9E\u9645\u522B\u540D",
      validator: {
        auto: {
          name: "\u81EA\u52A8Frontmatter",
          desc: "\u5982\u679C frontmatter \u4E0D\u5B58\u5728\uFF0C\u5219\u4F1A\u5728\u7F13\u5B58\u4E2D\u521B\u5EFA\u3002\u53EF\u80FD\u4F1A\u53D1\u751F\u526F\u4F5C\u7528\u3002"
        },
        required: {
          name: "\u6709Frontmatter\u624D\u751F\u6548",
          desc: "\u53EA\u5904\u7406\u6709 frontmatter \u7684\u6587\u4EF6\u3002"
        }
      },
      strategy: {
        ensure: {
          name: "\u589E\u5F3A",
          desc: "\u4EC5\u5F53\u6807\u9898\u4E0D\u5728\u522B\u540D\u4E2D\u65F6\uFF0C\u624D\u5C06\u6807\u9898\u8BBE\u7F6E\u4E3A\u522B\u540D"
        },
        adjust: {
          name: "\u8C03\u6574",
          desc: "\u5C06\u6807\u9898\u6DFB\u52A0\u5230\u522B\u540D\u4E2D\uFF0C\u4F46\u4E0D\u5F71\u54CD\u73B0\u6709\u522B\u540D"
        },
        replace: {
          name: "\u66FF\u6362",
          desc: "\u7528\u6807\u9898\u66FF\u6362\u5F53\u524D\u522B\u540D"
        }
      }
    },
    ["explorer" /* Explorer */]: {
      name: "\u6587\u4EF6\u8D44\u6E90\u7BA1\u7406\u5668",
      desc: "\u66FF\u6362\u6587\u4EF6\u8D44\u6E90\u7BA1\u7406\u5668\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["explorer:sort" /* ExplorerSort */]: {
      name: "\u6807\u9898\u6392\u5E8F",
      desc: "\u901A\u8FC7\u8D44\u6E90\u7BA1\u7406\u5668\u529F\u80FD\uFF0C\u6309\u6807\u9898\u5BF9\u8D44\u6E90\u7BA1\u7406\u5668\u4E2D\u7684\u6587\u4EF6\u8FDB\u884C\u6392\u5E8F"
    },
    ["graph" /* Graph */]: {
      name: "\u56FE\u8C31",
      desc: "\u66FF\u6362\u56FE\u8C31/\u672C\u5730\u56FE\u8C31\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["header" /* Header */]: {
      name: "\u9875\u9876\u6807\u9898",
      desc: "\u66FF\u6362Tab\u6807\u7B7E\u9875\u9876\u90E8\u7684\u6807\u9898\u5E76\u66F4\u65B0\u5B83\u4EEC"
    },
    ["starred" /* Starred */]: {
      name: "\u4E66\u7B7E",
      desc: "\u66FF\u6362\u5185\u7F6E\u4E66\u7B7E\u63D2\u4EF6\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["search" /* Search */]: {
      name: "\u641C\u7D22",
      desc: "\u66FF\u6362\u641C\u7D22\u9875\u9762\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["suggest" /* Suggest */]: {
      name: "\u5EFA\u8BAE",
      desc: "\u66FF\u6362\u5EFA\u8BAE\u7A97\u53E3\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["tab" /* Tab */]: {
      name: "\u6807\u7B7E\u9875",
      desc: "\u66FF\u6362Tab\u6807\u7B7E\u9875\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["inlineTitle" /* InlineTitle */]: {
      name: "\u9875\u5185\u6807\u9898",
      desc: "\u66FF\u6362\u9875\u9762\u5185\u663E\u793A\u7684\u6807\u9898"
    },
    ["canvas" /* Canvas */]: {
      name: "\u767D\u677F",
      desc: "\u66FF\u6362\u767D\u677F\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["backlink" /* Backlink */]: {
      name: "\u53CD\u5411\u94FE\u63A5",
      desc: "\u66FF\u6362\u53CD\u5411\u94FE\u63A5(\u94FE\u63A5\u63D0\u53CA)\u4E2D\u663E\u793A\u7684\u6807\u9898"
    },
    ["noteLink" /* NoteLink */]: {
      name: "\u7B14\u8BB0\u94FE\u63A5",
      desc: "\u66FF\u6362\u7B14\u8BB0\u4E2D\u7684\u5185\u90E8\u94FE\u63A5",
      strategy: {
        all: "\u66FF\u6362\u5168\u90E8\u94FE\u63A5",
        onlyEmpty: "\u53EA\u66FF\u6362\u6CA1\u6709\u522B\u540D\u7684\u94FE\u63A5"
      },
      approval: {
        showModal: "\u663E\u793A\u786E\u8BA4\u7A97\u53E3",
        auto: "\u4F7F\u7528\u81EA\u52A8\u786E\u8BA4"
      }
    }
  },
  manage: "\u7BA1\u7406",
  template: {
    features: {
      name: "\u7279\u6027\u6A21\u677F",
      desc: "\u6839\u636E\u5404\u7279\u6027\u529F\u80FD\u72EC\u7ACB\u7BA1\u7406\u6A21\u677F"
    },
    main: "\u4E3B\u6A21\u677F",
    fallback: "\u5907\u7528",
    placeholder: "\u8F93\u5165\u6A21\u677F",
    commmon: {
      main: {
        name: "\u901A\u7528\u4E3B\u6A21\u677F",
        desc: `\u8BBE\u7F6E yaml \u8DEF\u5F84\uFF0C\u8BE5\u503C\u5C06\u7528\u4E8E\u6587\u4EF6\u6807\u9898\u3002\u503C\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6216\u6570\u503C\u3002\u8FD8\u53EF\u4EE5\u4F7F\u7528\u7C7B\u4F3C\u6A21\u677F\u8DEF\u5F84 "{{ }}"\u3002
                \u8FD8\u53EF\u4EE5\u4F7F\u7528 #\u6807\u9898 \u6765\u4F7F\u7528\u4E00\u7EA7\u6807\u9898\uFF0C\u6216 _ basename \u548C\u5176\u4ED6\u4FDD\u7559\u5B57\u3002
                \u67E5\u9605 Readme \u4E86\u89E3\u66F4\u591A`
      },
      fallback: {
        name: "\u901A\u7528\u5907\u7528\u6A21\u677F",
        desc: "\u4F5C\u4E3A\u5907\u7528\u9009\u9879\u7684\u6A21\u677F\uFF0C\u5F53\u901A\u7528\u4E3B\u6A21\u677F\u65E0\u6CD5\u89E3\u6790\u51FA\u6765\u65F6\u4F7F\u7528"
      }
    },
    used: "\u901A\u7528\u6A21\u677F\u5C06\u4F1A\u4F7F\u7528. \u503C\u4E3A {{value}}",
    specific: "\u8FD9\u4E2A\u7279\u6027\u529F\u80FD\u5C06\u4F7F\u7528\u5F53\u524D\u6A21\u677F"
  },
  settings: "\u63D2\u4EF6\u8BBE\u7F6E",
  rule: {
    name: "\u89C4\u5219",
    path: {
      name: "\u6587\u4EF6\u8DEF\u5F84\u89C4\u5219",
      black: {
        name: "\u9ED1\u540D\u5355\u6A21\u5F0F",
        desc: "\u63D2\u4EF6\u5C06\u5FFD\u7565\u8DEF\u5F84\u4E2D\u7684\u6587\u4EF6\uFF0C\u6BCF\u4E2A\u8DEF\u5F84\u5FC5\u987B\u4F7F\u7528\u5728\u65B0\u884C\u4E2D\u5199\u5165."
      },
      white: {
        name: "\u767D\u540D\u5355\u6A21\u5F0F",
        desc: "\u63D2\u4EF6\u5C06\u5904\u7406\u8DEF\u5F84\u4E2D\u7684\u6587\u4EF6\uFF0C\u6BCF\u4E2A\u8DEF\u5F84\u5FC5\u987B\u4F7F\u7528\u5728\u65B0\u884C\u4E2D\u5199\u5165."
      }
    },
    delimiter: {
      name: "\u5217\u8868\u503C",
      desc: "\u8BBE\u7F6E\u5904\u7406\u5217\u8868\u503C\u7684\u89C4\u5219",
      first: "\u4F7F\u7528\u7B2C\u4E00\u4E2A\u503C",
      join: "\u7528\u5206\u9694\u7B26\u62FC\u63A5\u5168\u90E8",
      placeholder: {
        first: "\u4F1A\u91C7\u7528\u7B2C\u4E00\u4E2A\u503C",
        join: "\u8F93\u5165\u5206\u9694\u7B26"
      }
    }
  },
  features: "\u7279\u6027\u529F\u80FD",
  util: "\u5DE5\u5177",
  coffee: "\u5982\u679C\u60A8\u559C\u6B22\u6B64\u63D2\u4EF6\u5E76\u5E0C\u671B\u5E2E\u52A9/\u652F\u6301\u4F5C\u8005\u6301\u7EED\u5F00\u53D1\uFF0C\u8BF7\u70B9\u51FB\u4EE5\u4E0B\u6309\u94AE:",
  debug_info: {
    title: "\u8C03\u8BD5\u4FE1\u606F",
    desc: "\u5728\u7EC8\u7AEF\u4E2D\u663E\u793A\u8C03\u8BD5\u4FE1\u606F\u548C\u6355\u6349\u5230\u7684\u9519\u8BEF\u4FE1\u606F"
  },
  boot_delay: {
    title: "\u5EF6\u8FDF\u542F\u52A8\u52A0\u8F7D",
    desc: "\u63D2\u4EF6\u5C06\u5728\u6307\u5B9A\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\u540E\u52A0\u8F7D"
  },
  disabled: "\u7981\u7528",
  processor: {
    name: "\u5904\u7406\u5668",
    desc: "\u4FEE\u6539\u89E3\u6790\u7684\u6807\u9898",
    replace: {
      name: "\u66FF\u6362",
      desc: "\u5C06\u6267\u884C",
      pattern: {
        name: "\u6B63\u5219Pattern",
        desc: "\u5C06\u9996\u5148\u7528\u4F5C RegExp \u7684\u7B2C\u4E00\u4E2A\u53C2\u6570\uFF0C\u7136\u540E\u7528\u4F5C replace()\u7684\u7B2C\u4E00\u4E2A\u53C2\u6570"
      },
      flags: {
        name: "\u4FEE\u9970\u7B26Flags",
        desc: "\u5C06\u7528\u4F5C\u65B0RegExp \u7684\u7B2C\u4E8C\u4E2A\u53C2\u6570"
      },
      replacement: {
        name: "\u66FF\u6362\u503CReplacement",
        desc: "\u5C06\u7528\u4F5C replace() \u7684\u7B2C\u4E8C\u4E2A\u53C2\u6570"
      }
    },
    function: {
      name: "\u51FD\u6570",
      desc: "\u5C06\u600E\u6837\u8D77\u4F5C\u7528:",
      valueDesc: "\u4F60\u5728\u6587\u672C\u533A\u8F93\u5165\u7684\u503C"
    }
  },
  command: {
    features: {
      reload: "\u91CD\u65B0\u52A0\u8F7D\u7279\u6027\u529F\u80FD",
      disable: "\u7981\u7528\u7279\u6027\u529F\u80FD"
    }
  }
};
var zh_default = zh;

// src/i18n/zh-tw/index.ts
var zh_tw = {
  validator: "\u9A57\u8B49\u65B9\u5F0F",
  strategy: "\u7B56\u7565",
  cancel: "\u53D6\u6D88",
  apply: "\u61C9\u7528",
  feature: {
    ["alias" /* Alias */]: {
      name: "\u5225\u540DAlias",
      desc: "\u4FEE\u6539\u5143\u6578\u64DA\uFF08frontmatter\uFF09\u7DE9\u5B58\u4E2D\u7684\u5225\u540D\uFF0C\u4E0D\u5F71\u97FF\u5BE6\u969B\u5225\u540D",
      validator: {
        auto: {
          name: "\u81EA\u52D5Frontmatter",
          desc: "\u5982\u679C frontmatter \u4E0D\u5B58\u5728\uFF0C\u5247\u6703\u5728\u7DE9\u5B58\u4E2D\u5275\u5EFA\u3002\u53EF\u80FD\u6703\u767C\u751F\u526F\u4F5C\u7528\u3002"
        },
        required: {
          name: "\u6709Frontmatter\u624D\u751F\u6548",
          desc: "\u53EA\u8655\u7406\u6709 frontmatter \u7684\u6A94\u3002"
        }
      },
      strategy: {
        ensure: {
          name: "\u589E\u5F37",
          desc: "\u50C5\u7576\u6A19\u984C\u4E0D\u5728\u5225\u540D\u4E2D\u6642\uFF0C\u624D\u5C07\u6A19\u984C\u8A2D\u7F6E\u70BA\u5225\u540D"
        },
        adjust: {
          name: "\u8ABF\u6574",
          desc: "\u5C07\u6A19\u984C\u6DFB\u52A0\u5230\u5225\u540D\u4E2D\uFF0C\u4F46\u4E0D\u5F71\u97FF\u73FE\u6709\u5225\u540D"
        },
        replace: {
          name: "\u66FF\u63DB",
          desc: "\u7528\u6A19\u984C\u66FF\u63DB\u7576\u524D\u5225\u540D"
        }
      }
    },
    ["explorer" /* Explorer */]: {
      name: "\u6A94\u8CC7\u6E90\u7BA1\u7406\u5668",
      desc: "\u66FF\u63DB\u6A94\u8CC7\u6E90\u7BA1\u7406\u5668\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["explorer:sort" /* ExplorerSort */]: {
      name: "\u6A19\u984C\u6392\u5E8F",
      desc: "\u901A\u904E\u8CC7\u6E90\u7BA1\u7406\u5668\u529F\u80FD\uFF0C\u6309\u6A19\u984C\u5C0D\u8CC7\u6E90\u7BA1\u7406\u5668\u4E2D\u7684\u6A94\u9032\u884C\u6392\u5E8F"
    },
    ["graph" /* Graph */]: {
      name: "\u5716\u8B5C",
      desc: "\u66FF\u63DB\u5716\u8B5C/\u672C\u5730\u5716\u8B5C\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["header" /* Header */]: {
      name: "\u9801\u9802\u6A19\u984C",
      desc: "\u66FF\u63DBTab\u6A19\u7C64\u9801\u9802\u90E8\u7684\u6A19\u984C\u4E26\u66F4\u65B0\u5B83\u5011"
    },
    ["starred" /* Starred */]: {
      name: "\u66F8\u7C3D",
      desc: "\u66FF\u63DB\u5167\u7F6E\u66F8\u7C3D\u63D2\u4EF6\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["search" /* Search */]: {
      name: "\u641C\u7D22",
      desc: "\u66FF\u63DB\u641C\u7D22\u9801\u9762\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["suggest" /* Suggest */]: {
      name: "\u5EFA\u8B70",
      desc: "\u66FF\u63DB\u5EFA\u8B70\u7A97\u53E3\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["tab" /* Tab */]: {
      name: "\u6A19\u7C64\u9801",
      desc: "\u66FF\u63DBTab\u6A19\u7C64\u9801\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["inlineTitle" /* InlineTitle */]: {
      name: "\u9801\u5167\u6A19\u984C",
      desc: "\u66FF\u63DB\u9801\u9762\u5167\u986F\u793A\u7684\u6A19\u984C"
    },
    ["canvas" /* Canvas */]: {
      name: "\u767D\u677F",
      desc: "\u66FF\u63DB\u767D\u677F\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["backlink" /* Backlink */]: {
      name: "\u53CD\u5411\u93C8\u63A5",
      desc: "\u66FF\u63DB\u53CD\u5411\u93C8\u63A5(\u93C8\u63A5\u63D0\u53CA)\u4E2D\u986F\u793A\u7684\u6A19\u984C"
    },
    ["noteLink" /* NoteLink */]: {
      name: "\u7B46\u8A18\u93C8\u63A5",
      desc: "\u66FF\u63DB\u7B46\u8A18\u4E2D\u7684\u5167\u90E8\u93C8\u63A5",
      strategy: {
        all: "\u66FF\u63DB\u5168\u90E8\u93C8\u63A5",
        onlyEmpty: "\u53EA\u66FF\u63DB\u6C92\u6709\u5225\u540D\u7684\u93C8\u63A5"
      },
      approval: {
        showModal: "\u986F\u793A\u78BA\u8A8D\u7A97\u53E3",
        auto: "\u4F7F\u7528\u81EA\u52D5\u78BA\u8A8D"
      }
    }
  },
  manage: "\u7BA1\u7406",
  template: {
    features: {
      name: "\u7279\u6027\u7BC4\u672C",
      desc: "\u6839\u64DA\u5404\u7279\u6027\u529F\u80FD\u7368\u7ACB\u7BA1\u7406\u7BC4\u672C"
    },
    main: "\u4E3B\u7BC4\u672C",
    fallback: "\u5099\u7528",
    placeholder: "\u8F38\u5165\u7BC4\u672C",
    commmon: {
      main: {
        name: "\u901A\u7528\u4E3B\u7BC4\u672C",
        desc: `\u8A2D\u7F6E yaml \u8DEF\u5F91\uFF0C\u8A72\u503C\u5C07\u7528\u65BC\u6A94\u6A19\u984C\u3002\u503C\u5FC5\u9808\u662F\u5B57\u4E32\u6216\u6578\u503C\u3002\u9084\u53EF\u4EE5\u4F7F\u7528\u985E\u4F3C\u7BC4\u672C\u8DEF\u5F91 "{{ }}"\u3002
                \u9084\u53EF\u4EE5\u4F7F\u7528 #\u6A19\u984C \u4F86\u4F7F\u7528\u4E00\u7D1A\u6A19\u984C\uFF0C\u6216 _ basename \u548C\u5176\u4ED6\u4FDD\u7559\u5B57\u3002
                \u67E5\u95B1 Readme \u77AD\u89E3\u66F4\u591A`
      },
      fallback: {
        name: "\u901A\u7528\u5099\u7528\u7BC4\u672C",
        desc: "\u4F5C\u70BA\u5099\u7528\u9078\u9805\u7684\u7BC4\u672C\uFF0C\u7576\u901A\u7528\u4E3B\u7BC4\u672C\u7121\u6CD5\u89E3\u6790\u51FA\u4F86\u6642\u4F7F\u7528"
      }
    },
    used: "\u901A\u7528\u7BC4\u672C\u5C07\u6703\u4F7F\u7528. \u503C\u70BA {{value}}",
    specific: "\u9019\u500B\u7279\u6027\u529F\u80FD\u5C07\u4F7F\u7528\u7576\u524D\u7BC4\u672C"
  },
  settings: "\u63D2\u4EF6\u8A2D\u7F6E",
  rule: {
    name: "\u898F\u5247",
    path: {
      name: "\u6A94\u8DEF\u5F91\u898F\u5247",
      black: {
        name: "\u9ED1\u540D\u55AE\u6A21\u5F0F",
        desc: "\u63D2\u4EF6\u5C07\u5FFD\u7565\u8DEF\u5F91\u4E2D\u7684\u6A94\uFF0C\u6BCF\u500B\u8DEF\u5F91\u5FC5\u9808\u4F7F\u7528\u5728\u65B0\u884C\u4E2D\u5BEB\u5165."
      },
      white: {
        name: "\u767D\u540D\u55AE\u6A21\u5F0F",
        desc: "\u63D2\u4EF6\u5C07\u8655\u7406\u8DEF\u5F91\u4E2D\u7684\u6A94\uFF0C\u6BCF\u500B\u8DEF\u5F91\u5FC5\u9808\u4F7F\u7528\u5728\u65B0\u884C\u4E2D\u5BEB\u5165."
      }
    },
    delimiter: {
      name: "\u5217\u8868\u503C",
      desc: "\u8A2D\u7F6E\u8655\u7406\u5217\u8868\u503C\u7684\u898F\u5247",
      first: "\u4F7F\u7528\u7B2C\u4E00\u500B\u503C",
      join: "\u7528\u5206\u9694\u7B26\u865F\u62FC\u63A5\u5168\u90E8",
      placeholder: {
        first: "\u6703\u63A1\u7528\u7B2C\u4E00\u500B\u503C",
        join: "\u8F38\u5165\u5206\u9694\u7B26\u865F"
      }
    }
  },
  features: "\u7279\u6027\u529F\u80FD",
  util: "\u5DE5\u5177",
  coffee: "\u5982\u679C\u60A8\u559C\u6B61\u6B64\u63D2\u4EF6\u4E26\u5E0C\u671B\u5E6B\u52A9/\u652F\u6301\u4F5C\u8005\u6301\u7E8C\u958B\u767C\uFF0C\u8ACB\u9EDE\u64CA\u4EE5\u4E0B\u6309\u9215:",
  debug_info: {
    title: "\u8ABF\u8A66\u8CC7\u8A0A",
    desc: "\u5728\u7D42\u7AEF\u4E2D\u986F\u793A\u8ABF\u8A66\u8CC7\u8A0A\u548C\u6355\u6349\u5230\u7684\u932F\u8AA4\u8CC7\u8A0A"
  },
  boot_delay: {
    title: "\u5EF6\u9072\u555F\u52D5\u52A0\u8F09",
    desc: "\u63D2\u4EF6\u5C07\u5728\u6307\u5B9A\u6642\u9593\uFF08\u6BEB\u79D2\uFF09\u5F8C\u52A0\u8F09"
  },
  disabled: "\u7981\u7528",
  processor: {
    name: "\u8655\u7406\u5668",
    desc: "\u4FEE\u6539\u89E3\u6790\u7684\u6A19\u984C",
    replace: {
      name: "\u66FF\u63DB",
      desc: "\u5C07\u57F7\u884C",
      pattern: {
        name: "\u6B63\u5247Pattern",
        desc: "\u5C07\u9996\u5148\u7528\u4F5C RegExp \u7684\u7B2C\u4E00\u500B\u53C3\u6578\uFF0C\u7136\u5F8C\u7528\u4F5C replace()\u7684\u7B2C\u4E00\u500B\u53C3\u6578"
      },
      flags: {
        name: "\u4FEE\u98FE\u7B26Flags",
        desc: "\u5C07\u7528\u4F5C\u65B0RegExp \u7684\u7B2C\u4E8C\u500B\u53C3\u6578"
      },
      replacement: {
        name: "\u66FF\u63DB\u503CReplacement",
        desc: "\u5C07\u7528\u4F5C replace() \u7684\u7B2C\u4E8C\u500B\u53C3\u6578"
      }
    },
    function: {
      name: "\u51FD\u6578",
      desc: "\u5C07\u600E\u6A23\u8D77\u4F5C\u7528:",
      valueDesc: "\u4F60\u5728\u6587\u672C\u5340\u8F38\u5165\u7684\u503C"
    }
  },
  command: {
    features: {
      reload: "\u91CD\u65B0\u52A0\u8F09\u7279\u6027\u529F\u80FD",
      disable: "\u7981\u7528\u7279\u6027\u529F\u80FD"
    }
  }
};
var zh_tw_default = zh_tw;

// src/i18n/ko/index.ts
var ko = {};
var ko_default = ko;

// src/i18n/it/index.ts
var it = {};
var it_default = it;

// src/i18n/id/index.ts
var id2 = {};
var id_default = id2;

// src/i18n/ro/index.ts
var ro = {};
var ro_default = ro;

// src/i18n/pl/index.ts
var pl = {};
var pl_default = pl;

// src/i18n/cs/index.ts
var cs = {};
var cs_default = cs;

// src/i18n/de/index.ts
var de = {};
var de_default = de;

// src/i18n/es/index.ts
var es = {};
var es_default = es;

// src/i18n/fr/index.ts
var fr = {};
var fr_default = fr;

// src/i18n/no/index.ts
var no = {};
var no_default = no;

// src/i18n/pr-br/index.ts
var pr_br = {};
var pr_br_default = pr_br;

// src/i18n/pt/index.ts
var pt = {};
var pt_default = pt;

// src/i18n/ja/index.ts
var ja = {};
var ja_default = ja;

// src/i18n/da/index.ts
var da = {};
var da_default = da;

// src/i18n/uk/index.ts
var uk = {};
var uk_default = uk;

// src/i18n/sq/index.ts
var sq = {};
var sq_default = sq;

// src/i18n/th/index.ts
var th = {};
var th_default = th;

// src/i18n/fa/index.ts
var fa = {};
var fa_default = fa;

// src/i18n/tr/index.ts
var tr = {};
var tr_default = tr;

// src/i18n/nl/index.ts
var nl = {};
var nl_default = nl;

// src/i18n/am/index.ts
var am = {};
var am_default = am;

// src/i18n/ms/index.ts
var ms = {};
var ms_default = ms;

// src/i18n/Locale.ts
var defaultLocale = "en";
var locale = import_obsidian.moment.locale();
instance.init({
  lng: locale,
  fallbackLng: defaultLocale,
  resources: {
    en: { translation: en_default },
    ru: { translation: ru_default },
    zh: { translation: zh_default },
    "zh-TW": { translation: zh_tw_default },
    ko: { translation: ko_default },
    it: { translation: it_default },
    id: { translation: id_default },
    ro: { translation: ro_default },
    "pt-BR": { translation: pr_br_default },
    cs: { translation: cs_default },
    de: { translation: de_default },
    es: { translation: es_default },
    fr: { translation: fr_default },
    no: { translation: no_default },
    pl: { translation: pl_default },
    pt: { translation: pt_default },
    ja: { translation: ja_default },
    da: { translation: da_default },
    uk: { translation: uk_default },
    sq: { translation: sq_default },
    th: { translation: th_default },
    fa: { translation: fa_default },
    tr: { translation: tr_default },
    nl: { translation: nl_default },
    am: { translation: am_default },
    ms: { translation: ms_default }
  },
  nsSeparator: "|"
});
var resolved = instance.resolvedLanguage;
if (resolved !== locale) {
  if (instance.languages.includes(locale)) {
    console.warn(`Locale ${locale} empty. Resolved ${resolved}`);
  } else {
    console.warn(`Locale ${locale} does not exist. Resolved ${resolved}`);
  }
}
var t2 = (path, params) => {
  return instance.t(path, params);
};

// src/Settings/SettingsTab.ts
var SettingsTab = class {
  constructor(app, plugin, storage, dispatcher, factory) {
    this.storage = storage;
    this.dispatcher = dispatcher;
    this.factory = factory;
    const self2 = this;
    this.tab = new class extends import_obsidian2.PluginSettingTab {
      constructor() {
        super(...arguments);
        this.display = () => self2.display();
        this.hide = () => self2.hide();
      }
    }(app, plugin);
    this.updatePrevious();
    dispatcher.dispatch("settings.loaded", new Event({ settings: this.storage.collect() }));
  }
  get containerEl() {
    return this.getTab().containerEl;
  }
  getTab() {
    return this.tab;
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    containerEl.createEl("h2", { text: t2("settings") });
    const builders = this.factory("main");
    for (const k of this.orderedKeys) {
      for (const builder of builders) {
        if (builder.support(k)) {
          builder.build({
            name: k,
            item: this.storage.get(k),
            container: this.containerEl
          });
        }
      }
    }
    this.buildDonation();
  }
  get orderedKeys() {
    return ["templates", "processor", "rules", "features", "debug", "boot"];
  }
  buildDonation() {
    const div = this.containerEl.createEl("div");
    div.style.width = "75%";
    div.style.textAlign = "center";
    div.style.margin = "0 auto";
    const text = document.createElement("p");
    text.textContent = t2("coffee");
    div.appendChild(text);
    const anchor = document.createElement("a");
    anchor.setAttribute("href", "https://www.buymeacoffee.com/snezhig");
    anchor.appendChild(new DOMParser().parseFromString(coffee, "text/xml").documentElement);
    div.appendChild(anchor);
  }
  updatePrevious() {
    this.previous = JSON.parse(JSON.stringify(this.storage.collect()));
  }
  hide() {
    this.dispatch();
  }
  dispatch() {
    this.dispatcher.dispatch("settings:tab:close", null);
    const changed = ObjectHelper.compare(this.previous, this.storage.collect());
    if (Object.keys(changed).length === 0) {
      return;
    }
    this.dispatcher.dispatch(
      "settings:changed",
      new Event({
        old: this.previous,
        actual: this.storage.collect(),
        changed: ObjectHelper.compare(this.previous, this.storage.collect())
      })
    );
    this.updatePrevious();
  }
};
SettingsTab = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["obsidian:app"])),
  __decorateParam(1, inject(inversify_types_default["obsidian:plugin"])),
  __decorateParam(2, inject(inversify_types_default["settings:storage"])),
  __decorateParam(3, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(4, inject(inversify_types_default["factory:settings:builder"]))
], SettingsTab);
var coffee = '<svg width="150" height="42" viewBox="0 0 545 153" fill="none" xmlns="http://www.w3.org/2000/svg">\n<path d="M0 24.48C0 10.9601 10.9601 0 24.48 0H520.2C533.72 0 544.68 10.9601 544.68 24.48V128.52C544.68 142.04 533.72 153 520.2 153H24.48C10.9601 153 0 142.04 0 128.52V24.48Z" fill="#FFDD00"/>\n<path d="M109.522 50.3178L109.455 50.2783L109.299 50.2308C109.362 50.2836 109.44 50.3142 109.522 50.3178Z" fill="#0D0C22"/>\n<path d="M110.507 57.3134L110.432 57.3344L110.507 57.3134Z" fill="#0D0C22"/>\n<path d="M109.549 50.3062C109.54 50.3051 109.532 50.3031 109.524 50.3003C109.523 50.3058 109.523 50.3113 109.524 50.3168C109.533 50.3156 109.541 50.3119 109.549 50.3062Z" fill="#0D0C22"/>\n<path d="M109.523 50.3205H109.536V50.3127L109.523 50.3205Z" fill="#0D0C22"/>\n<path d="M110.447 57.3006L110.56 57.2361L110.602 57.2123L110.64 57.1715C110.569 57.2025 110.503 57.2462 110.447 57.3006Z" fill="#0D0C22"/>\n<path d="M109.715 50.4713L109.604 50.3659L109.529 50.3251C109.57 50.3963 109.636 50.4488 109.715 50.4713Z" fill="#0D0C22"/>\n<path d="M81.8801 118.353C81.7916 118.391 81.7142 118.451 81.6548 118.527L81.7246 118.482C81.772 118.439 81.8392 118.387 81.8801 118.353Z" fill="#0D0C22"/>\n<path d="M98.0456 115.173C98.0456 115.073 97.9968 115.091 98.0087 115.447C98.0087 115.418 98.0206 115.389 98.0258 115.361C98.0324 115.298 98.0377 115.236 98.0456 115.173Z" fill="#0D0C22"/>\n<path d="M96.3761 118.353C96.2877 118.391 96.2103 118.451 96.1509 118.527L96.2207 118.482C96.2681 118.439 96.3353 118.387 96.3761 118.353Z" fill="#0D0C22"/>\n<path d="M70.4886 119.11C70.4215 119.052 70.3393 119.013 70.2515 118.999C70.3226 119.034 70.3937 119.068 70.4412 119.094L70.4886 119.11Z" fill="#0D0C22"/>\n<path d="M67.9304 116.657C67.92 116.553 67.8881 116.453 67.8369 116.362C67.8732 116.456 67.9035 116.553 67.9278 116.652L67.9304 116.657Z" fill="#0D0C22"/>\n<path d="M85.1368 72.7737C81.6195 74.2794 77.628 75.9866 72.4549 75.9866C70.2908 75.9823 68.1373 75.6854 66.0527 75.104L69.6306 111.838C69.7572 113.373 70.4567 114.805 71.59 115.848C72.7233 116.892 74.2076 117.471 75.7482 117.47C75.7482 117.47 80.8212 117.734 82.514 117.734C84.3358 117.734 89.7988 117.47 89.7988 117.47C91.3391 117.47 92.8231 116.891 93.9562 115.848C95.0892 114.804 95.7885 113.373 95.9151 111.838L99.7472 71.2456C98.0347 70.6607 96.3064 70.2721 94.358 70.2721C90.9883 70.2708 88.2733 71.4313 85.1368 72.7737Z" fill="white"/>\n<path d="M54.9844 57.1021L55.045 57.1587L55.0845 57.1824C55.0541 57.1522 55.0205 57.1252 54.9844 57.1021Z" fill="#0D0C22"/>\n<path d="M116.299 53.7119L115.761 50.9943C115.277 48.5559 114.18 46.2519 111.677 45.3706C110.875 45.0887 109.964 44.9675 109.349 44.384C108.734 43.8004 108.552 42.8941 108.41 42.0536C108.147 40.511 107.899 38.9671 107.629 37.4272C107.396 36.1033 107.211 34.616 106.604 33.4015C105.814 31.7706 104.174 30.8169 102.543 30.1859C101.707 29.8739 100.854 29.61 99.9884 29.3955C95.9139 28.3205 91.63 27.9253 87.4382 27.7001C82.407 27.4225 77.3623 27.5061 72.343 27.9504C68.6071 28.2902 64.6723 28.7013 61.1221 29.9935C59.8245 30.4665 58.4875 31.0342 57.5008 32.0367C56.2902 33.2684 55.895 35.1733 56.7789 36.7092C57.4073 37.8 58.4717 38.5706 59.6006 39.0804C61.0711 39.7373 62.6068 40.2371 64.1822 40.5716C68.5689 41.5412 73.1124 41.9219 77.5939 42.0839C82.561 42.2844 87.5362 42.1219 92.4796 41.5978C93.7021 41.4635 94.9224 41.3023 96.1405 41.1144C97.575 40.8944 98.4958 39.0185 98.073 37.7117C97.5671 36.1494 96.2077 35.5434 94.6703 35.7792C94.4438 35.8148 94.2185 35.8477 93.9919 35.8807L93.8286 35.9044C93.3078 35.9702 92.787 36.0317 92.2662 36.0888C91.1904 36.2047 90.112 36.2996 89.0309 36.3733C86.6097 36.5419 84.1818 36.6197 81.7553 36.6236C79.371 36.6236 76.9853 36.5564 74.6062 36.3997C73.5207 36.3285 72.4379 36.2381 71.3577 36.1283C70.8663 36.0769 70.3763 36.0229 69.8862 35.9623L69.4199 35.903L69.3185 35.8886L68.835 35.8187C67.847 35.6699 66.859 35.4986 65.8816 35.2918C65.783 35.2699 65.6947 35.2151 65.6315 35.1363C65.5683 35.0575 65.5338 34.9594 65.5338 34.8584C65.5338 34.7574 65.5683 34.6594 65.6315 34.5806C65.6947 34.5018 65.783 34.4469 65.8816 34.425H65.9C66.7471 34.2445 67.6007 34.0904 68.4569 33.956C68.7424 33.9113 69.0287 33.8673 69.3158 33.8243H69.3237C69.8599 33.7887 70.3987 33.6926 70.9322 33.6293C75.574 33.1465 80.2434 32.9819 84.9077 33.1367C87.1721 33.2025 89.4353 33.3356 91.6892 33.5648C92.174 33.6149 92.6562 33.6676 93.1383 33.7268C93.3227 33.7492 93.5085 33.7756 93.6942 33.798L94.0683 33.852C95.1591 34.0144 96.2441 34.2116 97.3234 34.4435C98.9227 34.7912 100.976 34.9045 101.688 36.6566C101.914 37.2125 102.017 37.8303 102.142 38.4139L102.302 39.1581C102.306 39.1715 102.309 39.1852 102.311 39.199C102.688 40.9554 103.065 42.7118 103.442 44.4683C103.47 44.598 103.471 44.7321 103.444 44.8621C103.418 44.9921 103.365 45.1153 103.289 45.2239C103.213 45.3326 103.115 45.4244 103.002 45.4936C102.889 45.5628 102.762 45.6079 102.631 45.6262H102.62L102.39 45.6578L102.162 45.6881C101.44 45.7821 100.717 45.8699 99.9936 45.9516C98.5683 46.114 97.1408 46.2546 95.711 46.3731C92.87 46.6094 90.0233 46.7644 87.1708 46.8381C85.7174 46.8768 84.2644 46.8948 82.8118 46.8921C77.0301 46.8876 71.2534 46.5516 65.5101 45.8857C64.8883 45.8119 64.2666 45.7329 63.6448 45.6525C64.1269 45.7145 63.2944 45.6051 63.1258 45.5814C62.7306 45.5261 62.3354 45.4686 61.9402 45.4088C60.6136 45.2099 59.295 44.9649 57.9711 44.7502C56.3705 44.4867 54.8398 44.6185 53.3921 45.4088C52.2037 46.0591 51.2419 47.0564 50.6349 48.2674C50.0105 49.5584 49.8248 50.964 49.5455 52.3511C49.2662 53.7383 48.8315 55.2308 48.9962 56.6548C49.3505 59.7281 51.4991 62.2258 54.5895 62.7843C57.4968 63.3112 60.42 63.7381 63.351 64.1016C74.8648 65.5118 86.4968 65.6805 98.0466 64.6049C98.9872 64.517 99.9265 64.4213 100.864 64.3177C101.157 64.2855 101.454 64.3192 101.732 64.4165C102.01 64.5137 102.263 64.6719 102.472 64.8795C102.681 65.0872 102.842 65.339 102.941 65.6165C103.04 65.894 103.076 66.1902 103.046 66.4834L102.753 69.3261C102.164 75.0705 101.575 80.8145 100.986 86.558C100.371 92.5896 99.7521 98.6208 99.1295 104.651C98.9538 106.35 98.7782 108.048 98.6025 109.746C98.4339 111.417 98.4102 113.142 98.0927 114.794C97.5922 117.391 95.8335 118.987 93.2674 119.57C90.9164 120.105 88.5148 120.386 86.1038 120.408C83.431 120.422 80.7594 120.304 78.0866 120.318C75.2333 120.334 71.7384 120.071 69.5358 117.947C67.6007 116.082 67.3333 113.161 67.0698 110.636C66.7185 107.293 66.3703 103.95 66.0252 100.607L64.0887 82.0212L62.8359 69.9953C62.8149 69.7964 62.7938 69.6001 62.774 69.3999C62.6239 67.9654 61.6082 66.5611 60.0077 66.6335C58.6376 66.6941 57.0806 67.8586 57.2413 69.3999L58.17 78.3155L60.0906 96.7581C60.6378 101.997 61.1836 107.236 61.7281 112.476C61.8335 113.48 61.9323 114.487 62.0429 115.49C62.6449 120.976 66.834 123.932 72.0216 124.764C75.0515 125.252 78.1551 125.352 81.2297 125.402C85.1711 125.465 89.1521 125.617 93.029 124.903C98.7738 123.849 103.084 120.013 103.699 114.062C103.875 112.345 104.051 110.626 104.226 108.908C104.81 103.224 105.393 97.5397 105.976 91.855L107.88 73.2807L108.754 64.7682C108.797 64.3461 108.976 63.9492 109.262 63.6363C109.549 63.3234 109.929 63.111 110.345 63.0307C111.988 62.7105 113.558 62.1639 114.727 60.9137C116.587 58.9232 116.957 56.3281 116.299 53.7119ZM54.5052 55.5483C54.5302 55.5364 54.4841 55.7511 54.4644 55.8513C54.4604 55.6998 54.4683 55.5654 54.5052 55.5483ZM54.6646 56.7813C54.6778 56.7721 54.7173 56.8248 54.7581 56.888C54.6962 56.83 54.6567 56.7866 54.6633 56.7813H54.6646ZM54.8214 56.9881C54.878 57.0843 54.9083 57.1449 54.8214 56.9881V56.9881ZM55.1362 57.2437H55.1441C55.1441 57.2529 55.1586 57.2621 55.1639 57.2713C55.1551 57.2612 55.1454 57.2519 55.1349 57.2437H55.1362ZM110.269 56.8616C109.679 57.4228 108.789 57.6837 107.911 57.8141C98.0572 59.2763 88.06 60.0166 78.0984 59.6899C70.9691 59.4462 63.9148 58.6545 56.8566 57.6573C56.165 57.5598 55.4155 57.4334 54.9399 56.9236C54.0441 55.9619 54.4841 54.0254 54.7173 52.8636C54.9307 51.7992 55.3391 50.3804 56.605 50.2289C58.581 49.9971 60.8758 50.8309 62.8307 51.1273C65.1843 51.4865 67.5467 51.7741 69.9179 51.9902C80.0375 52.9123 90.3271 52.7687 100.402 51.4198C102.238 51.173 104.068 50.8863 105.891 50.5596C107.516 50.2684 109.316 49.7218 110.298 51.404C110.971 52.55 111.06 54.0834 110.956 55.3783C110.924 55.9425 110.678 56.4732 110.267 56.8616H110.269Z" fill="#0D0C22"/>\n<path fill-rule="evenodd" clip-rule="evenodd" d="M170.036 84.2397C169.461 85.3378 168.67 86.2942 167.663 87.1057C166.656 87.9178 165.482 88.579 164.139 89.0881C162.797 89.5984 161.446 89.9408 160.088 90.1153C158.729 90.2905 157.41 90.2753 156.133 90.0674C154.854 89.8608 153.766 89.439 152.872 88.8014L153.88 78.3397C154.806 78.0216 155.972 77.6949 157.379 77.3604C158.785 77.0264 160.231 76.787 161.718 76.644C163.205 76.5004 164.61 76.5173 165.937 76.6919C167.263 76.867 168.31 77.2888 169.077 77.9579C169.493 78.3397 169.845 78.7537 170.132 79.1997C170.42 79.6458 170.595 80.1076 170.66 80.5852C170.819 81.9227 170.612 83.1409 170.036 84.2397ZM155.413 61.9545C156.084 61.5406 156.892 61.1739 157.834 60.8551C158.777 60.5376 159.744 60.3139 160.735 60.1867C161.725 60.06 162.692 60.043 163.636 60.1388C164.578 60.2345 165.41 60.497 166.129 60.9267C166.848 61.357 167.383 61.9782 167.735 62.7897C168.086 63.6024 168.182 64.6296 168.022 65.8714C167.895 66.8587 167.502 67.695 166.848 68.3793C166.193 69.0647 165.393 69.6374 164.451 70.0993C163.508 70.5617 162.509 70.9277 161.455 71.1974C160.399 71.4689 159.384 71.6683 158.41 71.795C157.435 71.9229 156.588 72.0029 155.869 72.0338C155.15 72.0659 154.678 72.0816 154.454 72.0816L155.413 61.9545ZM175.214 77.4798C174.703 76.3658 174.016 75.3864 173.153 74.5416C172.29 73.698 171.266 73.0853 170.084 72.7029C170.595 72.2889 171.099 71.6362 171.595 70.7441C172.09 69.8532 172.513 68.8811 172.865 67.8302C173.216 66.7787 173.457 65.7205 173.584 64.6533C173.711 63.5866 173.663 62.6709 173.441 61.906C172.896 59.9958 172.042 58.4988 170.875 57.4158C169.708 56.3334 168.35 55.5849 166.8 55.1704C165.249 54.7577 163.54 54.6692 161.67 54.908C159.8 55.1467 157.89 55.6164 155.941 56.317C155.941 56.1582 155.957 55.991 155.989 55.8158C156.02 55.6413 156.036 55.4576 156.036 55.2661C156.036 54.7886 155.797 54.3752 155.317 54.0243C154.838 53.674 154.287 53.4674 153.664 53.4031C153.04 53.3401 152.433 53.4746 151.841 53.8092C151.25 54.1437 150.842 54.7577 150.619 55.6479C150.363 58.5146 150.107 61.4927 149.852 64.5812C149.596 67.6708 149.324 70.792 149.037 73.9453C148.749 77.0979 148.461 80.227 148.174 83.3318C147.886 86.4372 147.598 89.4226 147.311 92.2886C147.407 93.1486 147.646 93.8177 148.03 94.2953C148.413 94.7734 148.861 95.0601 149.372 95.1553C149.883 95.251 150.419 95.1625 150.978 94.8922C151.537 94.6225 152.025 94.1516 152.441 93.4832C153.719 94.1838 155.158 94.6377 156.756 94.845C158.354 95.0516 159.975 95.0516 161.623 94.845C163.268 94.6377 164.89 94.248 166.488 93.6741C168.086 93.1013 169.541 92.3844 170.851 91.525C172.162 90.665 173.264 89.685 174.16 88.5869C175.054 87.4875 175.646 86.3014 175.933 85.0281C176.221 83.7221 176.301 82.4167 176.173 81.1106C176.045 79.8052 175.725 78.5955 175.214 77.4798Z" fill="#0D0C23"/>\n<path fill-rule="evenodd" clip-rule="evenodd" d="M221.989 102.702C221.814 103.753 221.565 104.86 221.246 106.023C220.926 107.184 220.551 108.244 220.12 109.2C219.688 110.155 219.209 110.926 218.682 111.516C218.154 112.105 217.586 112.352 216.979 112.257C216.5 112.192 216.196 111.89 216.069 111.349C215.94 110.807 215.94 110.138 216.069 109.343C216.196 108.546 216.443 107.646 216.811 106.643C217.179 105.64 217.627 104.644 218.154 103.658C218.682 102.67 219.281 101.723 219.952 100.815C220.623 99.9082 221.326 99.1512 222.061 98.5464C222.221 98.7373 222.293 99.2149 222.277 99.9797C222.26 100.744 222.165 101.652 221.989 102.702ZM238.243 81.9697C237.811 81.4921 237.284 81.2218 236.66 81.1576C236.037 81.0939 235.405 81.4442 234.767 82.2085C234.351 82.9727 233.823 83.7054 233.184 84.406C232.545 85.1072 231.882 85.7436 231.195 86.3169C230.507 86.8896 229.852 87.3841 229.229 87.7975C228.606 88.212 228.118 88.5144 227.767 88.7053C227.639 87.6866 227.566 86.5878 227.551 85.409C227.534 84.2308 227.559 83.0369 227.623 81.8266C227.718 80.1067 227.918 78.3715 228.222 76.6194C228.526 74.868 228.965 73.148 229.541 71.4595C229.541 70.5686 229.332 69.8438 228.917 69.2862C228.501 68.7293 227.998 68.3784 227.407 68.2353C226.815 68.0923 226.209 68.1717 225.585 68.4741C224.962 68.7771 224.427 69.3268 223.979 70.122C223.596 71.1735 223.156 72.3516 222.661 73.6571C222.165 74.9631 221.606 76.2928 220.983 77.6461C220.359 79.0006 219.664 80.3139 218.897 81.5873C218.13 82.8618 217.291 83.9927 216.38 84.9793C215.469 85.9666 214.478 86.7393 213.408 87.2963C212.336 87.8538 211.179 88.1005 209.932 88.0369C209.356 87.8775 208.94 87.4478 208.685 86.7466C208.429 86.0466 208.277 85.1702 208.23 84.1193C208.182 83.0684 208.23 81.9139 208.373 80.6557C208.517 79.3982 208.709 78.1479 208.949 76.9061C209.188 75.6637 209.452 74.4855 209.739 73.371C210.027 72.2565 210.298 71.3165 210.554 70.5523C210.938 69.6292 210.938 68.8559 210.554 68.2353C210.171 67.6141 209.644 67.2008 208.973 66.9929C208.302 66.7863 207.598 66.7947 206.863 67.0172C206.128 67.2402 205.6 67.7335 205.281 68.4977C204.737 69.8044 204.241 71.2686 203.794 72.8928C203.347 74.5171 202.987 76.1976 202.716 77.9328C202.444 79.6691 202.291 81.3891 202.26 83.0927C202.258 83.2036 202.263 83.309 202.263 83.4193C201.566 85.2708 200.902 86.6702 200.271 87.6066C199.456 88.8174 198.536 89.3429 197.514 89.1829C197.065 88.992 196.771 88.5465 196.627 87.8453C196.482 87.1453 196.435 86.2854 196.482 85.2654C196.531 84.2472 196.651 83.0927 196.842 81.8024C197.035 80.5127 197.273 79.1752 197.561 77.7897C197.849 76.4037 198.153 75.0116 198.472 73.6098C198.792 72.2086 199.079 70.8868 199.336 69.6444C199.304 68.5299 198.976 67.6784 198.352 67.0887C197.73 66.5002 196.858 66.2693 195.74 66.396C194.973 66.7147 194.405 67.1293 194.038 67.6384C193.67 68.1474 193.374 68.8008 193.151 69.5965C193.022 70.0111 192.831 70.8389 192.575 72.0813C192.319 73.3225 191.992 74.7486 191.592 76.3564C191.193 77.9655 190.721 79.6449 190.178 81.3963C189.635 83.1478 189.027 84.7333 188.357 86.1496C187.685 87.5666 186.95 88.7053 186.151 89.5653C185.352 90.4247 184.489 90.7756 183.562 90.6162C183.05 90.5205 182.723 89.995 182.579 89.0399C182.435 88.0841 182.412 86.9066 182.507 85.5048C182.603 84.1036 182.795 82.5666 183.082 80.8951C183.37 79.223 183.665 77.6388 183.969 76.1413C184.273 74.6449 184.553 73.3225 184.809 72.1765C185.064 71.0298 185.24 70.2656 185.336 69.8838C185.336 68.9602 185.127 68.2202 184.713 67.662C184.297 67.1056 183.794 66.7547 183.202 66.6111C182.61 66.4681 182.003 66.5475 181.381 66.8499C180.757 67.1529 180.222 67.7026 179.774 68.4977C179.614 69.3577 179.406 70.3535 179.151 71.4838C178.895 72.614 178.648 73.7765 178.408 74.971C178.168 76.1655 177.944 77.3358 177.737 78.4824C177.529 79.6291 177.377 80.6321 177.281 81.4921C177.217 82.1606 177.145 82.9812 177.066 83.9521C176.985 84.9242 176.945 85.9508 176.945 87.0332C176.945 88.1169 177.025 89.1914 177.186 90.258C177.345 91.3253 177.633 92.3047 178.048 93.1956C178.463 94.0877 179.047 94.8198 179.799 95.3931C180.549 95.9664 181.5 96.2846 182.651 96.3489C183.833 96.4119 184.864 96.3252 185.744 96.0858C186.622 95.847 187.421 95.4725 188.141 94.9628C188.86 94.4543 189.515 93.8489 190.107 93.1477C190.697 92.4477 191.281 91.6835 191.856 90.855C192.4 92.0659 193.103 93.0047 193.966 93.6737C194.829 94.3422 195.74 94.741 196.699 94.8677C197.657 94.9943 198.633 94.8604 199.624 94.4616C200.614 94.064 201.509 93.3871 202.308 92.4313C202.835 91.8453 203.331 91.1792 203.797 90.4429C203.995 90.7877 204.205 91.1204 204.442 91.4277C205.225 92.4477 206.288 93.1477 207.631 93.5301C209.069 93.9125 210.474 93.9768 211.849 93.7216C213.223 93.4671 214.534 93.0047 215.78 92.3362C217.027 91.6671 218.185 90.8635 219.257 89.9235C220.327 88.9841 221.262 88.0053 222.061 86.9854C222.029 87.7181 222.013 88.4114 222.013 89.0635C222.013 89.7168 221.997 90.4247 221.966 91.1895C220.367 92.3047 218.857 93.6422 217.435 95.2022C216.012 96.7622 214.765 98.4264 213.695 100.194C212.624 101.961 211.785 103.753 211.179 105.568C210.571 107.384 210.275 109.08 210.291 110.657C210.307 112.233 210.682 113.61 211.418 114.788C212.152 115.967 213.351 116.81 215.013 117.32C216.74 117.862 218.257 117.877 219.569 117.368C220.879 116.858 222.021 116.014 222.996 114.836C223.971 113.658 224.77 112.233 225.394 110.561C226.017 108.889 226.512 107.145 226.88 105.33C227.247 103.515 227.479 101.73 227.575 99.9797C227.671 98.2276 227.671 96.6664 227.575 95.2974C230.324 94.1513 232.577 92.7022 234.335 90.9501C236.093 89.1999 237.547 87.352 238.698 85.409C239.049 84.9314 239.169 84.3581 239.058 83.6896C238.945 83.0206 238.674 82.4472 238.243 81.9697Z" fill="#0D0C23"/>\n<path fill-rule="evenodd" clip-rule="evenodd" d="M298.724 78.9135C298.82 78.1814 298.964 77.4087 299.155 76.5966C299.347 75.7845 299.587 74.996 299.875 74.2318C300.162 73.4676 300.498 72.807 300.882 72.2494C301.265 71.6924 301.673 71.2943 302.104 71.0549C302.536 70.8167 302.974 70.8403 303.423 71.1264C303.902 71.4137 304.197 72.0185 304.31 72.9415C304.421 73.8663 304.31 74.853 303.974 75.9039C303.638 76.9554 303.039 77.942 302.176 78.8657C301.313 79.7899 300.146 80.3941 298.676 80.6808C298.612 80.236 298.628 79.6463 298.724 78.9135ZM315.336 80.8717C314.809 80.7135 314.306 80.6972 313.826 80.8244C313.347 80.9517 313.043 81.2862 312.916 81.8281C312.659 82.8468 312.251 83.8898 311.692 84.9565C311.133 86.0238 310.446 87.0346 309.632 87.9904C308.817 88.9455 307.897 89.7898 306.875 90.5219C305.851 91.2546 304.781 91.78 303.662 92.0982C302.543 92.4491 301.616 92.4885 300.882 92.2176C300.146 91.9479 299.563 91.4855 299.132 90.8328C298.7 90.1801 298.388 89.3916 298.197 88.468C298.005 87.5443 297.893 86.5892 297.861 85.6013C299.683 85.7292 301.305 85.4032 302.728 84.622C304.149 83.8426 305.356 82.8068 306.347 81.5171C307.337 80.2275 308.089 78.7784 308.6 77.1699C309.111 75.5621 309.399 73.9615 309.463 72.3688C309.495 70.8718 309.272 69.6064 308.792 68.5713C308.313 67.5367 307.665 66.7313 306.85 66.1586C306.036 65.5853 305.1 65.2507 304.046 65.1556C302.992 65.0598 301.92 65.2034 300.833 65.5853C299.522 66.0313 298.412 66.7555 297.501 67.7592C296.59 68.7622 295.831 69.9252 295.224 71.2464C294.617 72.5682 294.137 73.993 293.786 75.5215C293.434 77.0505 293.178 78.5554 293.019 80.0366C292.875 81.3656 292.798 82.6365 292.771 83.8632C292.702 84.0189 292.636 84.1686 292.563 84.3353C292.067 85.4668 291.491 86.5734 290.837 87.6558C290.182 88.7389 289.454 89.6467 288.656 90.3788C287.857 91.1116 287.026 91.3661 286.163 91.1431C285.651 91.0164 285.372 90.4261 285.324 89.3758C285.276 88.3243 285.331 87.0189 285.491 85.4583C285.651 83.8983 285.835 82.2093 286.043 80.3941C286.25 78.579 286.354 76.8439 286.354 75.1875C286.354 73.7542 286.082 72.3773 285.539 71.0549C284.995 69.7343 284.252 68.6349 283.31 67.7592C282.367 66.8828 281.272 66.3016 280.026 66.0156C278.779 65.7283 277.437 65.9198 275.999 66.5883C274.56 67.2574 273.417 68.1967 272.571 69.407C271.723 70.6179 270.948 71.8912 270.245 73.2288C269.989 72.2094 269.614 71.2628 269.118 70.3864C268.623 69.5107 268.016 68.7464 267.297 68.0931C266.577 67.441 265.769 66.9313 264.876 66.5646C263.981 66.1992 263.037 66.0156 262.046 66.0156C261.088 66.0156 260.201 66.1992 259.386 66.5646C258.571 66.9313 257.828 67.4004 257.156 67.9737C256.485 68.5476 255.878 69.1919 255.334 69.9088C254.791 70.6252 254.311 71.3343 253.896 72.0343C253.831 71.2064 253.76 70.4822 253.681 69.8603C253.6 69.2398 253.456 68.7143 253.249 68.2846C253.041 67.8543 252.746 67.5283 252.362 67.3052C251.978 67.0828 251.435 66.9707 250.732 66.9707C250.38 66.9707 250.028 67.0422 249.677 67.1852C249.325 67.3289 249.013 67.5283 248.742 67.7828C248.47 68.0386 248.263 68.3482 248.119 68.7143C247.975 69.0804 247.936 69.5028 247.999 69.9803C248.031 70.3312 248.119 70.7525 248.263 71.2464C248.406 71.7403 248.542 72.3858 248.67 73.1809C248.798 73.9773 248.902 74.9409 248.982 76.0712C249.062 77.2021 249.085 78.5875 249.054 80.2275C249.021 81.8681 248.902 83.7862 248.694 85.9837C248.486 88.1813 248.158 90.7291 247.711 93.6267C247.647 94.2957 247.903 94.8376 248.479 95.2515C249.054 95.6648 249.709 95.9036 250.444 95.9678C251.179 96.0315 251.875 95.9036 252.53 95.586C253.185 95.2666 253.561 94.7097 253.656 93.9139C253.752 92.417 253.936 90.8249 254.208 89.1364C254.479 87.4492 254.815 85.7771 255.215 84.1207C255.614 82.465 256.069 80.8887 256.581 79.3911C257.092 77.8942 257.66 76.573 258.283 75.4263C258.907 74.2797 259.554 73.3645 260.225 72.6797C260.896 71.9949 261.599 71.6524 262.335 71.6524C263.229 71.6524 263.924 72.0579 264.42 72.87C264.915 73.6827 265.266 74.7263 265.475 75.999C265.682 77.2736 265.778 78.6675 265.763 80.1796C265.746 81.6923 265.682 83.1492 265.571 84.5504C265.459 85.9522 265.331 87.2019 265.187 88.3007C265.043 89.3995 264.939 90.1564 264.876 90.5697C264.876 91.3025 265.155 91.8831 265.714 92.3134C266.273 92.743 266.896 92.9982 267.584 93.0776C268.272 93.1576 268.918 93.0297 269.526 92.6952C270.133 92.3606 270.485 91.7964 270.581 90.9994C270.9 88.7067 271.34 86.4062 271.899 84.0971C272.458 81.7881 273.098 79.7184 273.817 77.8869C274.536 76.0554 275.335 74.5585 276.214 73.3961C277.093 72.2343 278.028 71.6524 279.019 71.6524C279.53 71.6524 279.922 72.0033 280.193 72.7033C280.465 73.4039 280.601 74.3591 280.601 75.5694C280.601 76.4615 280.529 77.3772 280.386 78.3166C280.241 79.256 280.074 80.2275 279.882 81.2305C279.69 82.2341 279.522 83.2608 279.378 84.3117C279.235 85.3632 279.163 86.4613 279.163 87.608C279.163 88.4043 279.243 89.3279 279.403 90.3788C279.562 91.4291 279.865 92.4255 280.313 93.3642C280.761 94.3042 281.376 95.1 282.16 95.7527C282.943 96.4054 283.941 96.7321 285.155 96.7321C286.978 96.7321 288.591 96.3418 289.998 95.5618C291.404 94.7818 292.611 93.763 293.618 92.5049C293.67 92.4388 293.718 92.3685 293.769 92.3031C293.846 92.4891 293.914 92.6861 294.001 92.863C294.688 94.2642 295.623 95.3466 296.806 96.1115C297.988 96.8757 299.379 97.2975 300.978 97.3775C302.575 97.4563 304.317 97.1618 306.204 96.4933C307.609 95.9836 308.832 95.3466 309.871 94.5824C310.909 93.8182 311.844 92.8867 312.675 91.7879C313.507 90.6891 314.265 89.4231 314.953 87.9904C315.641 86.5565 316.335 84.9171 317.038 83.0692C317.166 82.5608 317.046 82.1068 316.679 81.7081C316.311 81.3105 315.864 81.0317 315.336 80.8717Z" fill="#0D0C23"/>\n<path fill-rule="evenodd" clip-rule="evenodd" d="M341.393 75.5432C341.233 76.4832 341.018 77.5189 340.746 78.6486C340.474 79.7795 340.131 80.9498 339.715 82.1601C339.3 83.3703 338.788 84.4612 338.181 85.4321C337.574 86.4042 336.878 87.1757 336.096 87.7491C335.312 88.3224 334.41 88.5612 333.387 88.4654C332.875 88.4024 332.483 88.0521 332.212 87.4145C331.94 86.7782 331.797 85.9655 331.78 84.9782C331.764 83.9915 331.852 82.9085 332.044 81.7298C332.236 80.5522 332.531 79.3971 332.932 78.2662C333.331 77.1365 333.818 76.0929 334.393 75.1371C334.969 74.182 335.632 73.4414 336.383 72.916C337.134 72.3905 337.958 72.1445 338.852 72.1754C339.747 72.2075 340.706 72.6529 341.729 73.5129C341.664 73.9275 341.553 74.6044 341.393 75.5432ZM358.437 79.1977C357.941 78.9431 357.43 78.888 356.903 79.031C356.376 79.174 356 79.6601 355.777 80.488C355.649 81.3801 355.361 82.4304 354.914 83.6406C354.466 84.8509 353.914 85.9982 353.26 87.08C352.604 88.163 351.853 89.063 351.006 89.7793C350.159 90.4963 349.256 90.823 348.298 90.7581C347.498 90.6951 346.938 90.289 346.62 89.5406C346.299 88.7921 346.132 87.8533 346.116 86.7218C346.099 85.5921 346.212 84.3182 346.451 82.9007C346.691 81.4837 346.979 80.0746 347.314 78.6722C347.65 77.2716 347.994 75.9256 348.346 74.6359C348.697 73.3463 348.984 72.2554 349.209 71.3639C349.464 70.5675 349.384 69.8912 348.969 69.333C348.553 68.7766 348.034 68.3778 347.411 68.1391C346.787 67.9003 346.155 67.8366 345.516 67.9481C344.877 68.0597 344.462 68.4021 344.27 68.9748C342.384 67.3506 340.57 66.4748 338.829 66.3476C337.086 66.2203 335.48 66.6027 334.01 67.4942C332.539 68.3857 331.237 69.6754 330.103 71.3639C328.968 73.0523 328.049 74.8911 327.345 76.8814C326.642 78.8716 326.203 80.9025 326.027 82.9722C325.851 85.0424 325.987 86.9297 326.435 88.6333C326.883 90.3369 327.673 91.7308 328.808 92.8126C329.942 93.8956 331.485 94.4375 333.435 94.4375C334.298 94.4375 335.129 94.2623 335.928 93.912C336.726 93.5611 337.462 93.1472 338.133 92.6696C338.804 92.192 339.395 91.6902 339.908 91.1648C340.418 90.6393 340.818 90.2018 341.106 89.8509C341.329 90.9975 341.697 91.9696 342.209 92.7654C342.719 93.5611 343.303 94.215 343.958 94.7235C344.613 95.2326 345.301 95.6071 346.02 95.8465C346.739 96.0853 347.435 96.2047 348.105 96.2047C349.608 96.2047 351.013 95.695 352.325 94.6756C353.635 93.6575 354.81 92.4066 355.849 90.926C356.887 89.4448 357.743 87.8848 358.413 86.2442C359.085 84.6043 359.532 83.1473 359.756 81.8728C359.98 81.3952 359.939 80.894 359.636 80.3686C359.332 79.8431 358.933 79.4534 358.437 79.1977Z" fill="#0D0C23"/>\n<path fill-rule="evenodd" clip-rule="evenodd" d="M444.738 105.571C444.467 106.653 444.043 107.57 443.467 108.318C442.892 109.066 442.173 109.456 441.31 109.489C440.767 109.52 440.351 109.233 440.063 108.629C439.776 108.023 439.576 107.243 439.464 106.288C439.352 105.332 439.304 104.265 439.32 103.087C439.336 101.909 439.384 100.746 439.464 99.5996C439.543 98.4536 439.64 97.3857 439.752 96.3991C439.863 95.4112 439.951 94.6482 440.015 94.1064C441.102 94.2336 442.006 94.7027 442.724 95.5154C443.443 96.3275 443.995 97.2906 444.378 98.4057C444.762 99.5202 444.985 100.723 445.05 102.012C445.113 103.302 445.009 104.488 444.738 105.571ZM427.382 105.571C427.111 106.653 426.687 107.57 426.112 108.318C425.537 109.066 424.817 109.456 423.954 109.489C423.411 109.52 422.996 109.233 422.708 108.629C422.42 108.023 422.22 107.243 422.109 106.288C421.996 105.332 421.948 104.265 421.965 103.087C421.98 101.909 422.028 100.746 422.109 99.5996C422.188 98.4536 422.284 97.3857 422.396 96.3991C422.508 95.4112 422.595 94.6482 422.66 94.1064C423.746 94.2336 424.65 94.7027 425.368 95.5154C426.088 96.3275 426.639 97.2906 427.023 98.4057C427.407 99.5202 427.63 100.723 427.694 102.012C427.757 103.302 427.653 104.488 427.382 105.571ZM409.572 78.4375C409.539 79.2011 409.467 79.8781 409.355 80.4672C409.243 81.0575 409.092 81.4308 408.9 81.5902C408.548 81.3987 408.116 80.906 407.605 80.109C407.094 79.3133 406.695 78.4127 406.406 77.4096C406.119 76.4066 406.03 75.42 406.143 74.4479C406.254 73.477 406.758 72.7212 407.653 72.1788C408.004 71.9879 408.308 72.0594 408.564 72.394C408.82 72.7285 409.027 73.2139 409.188 73.8509C409.347 74.4885 409.458 75.2206 409.523 76.0485C409.587 76.8769 409.603 77.6727 409.572 78.4375ZM405.328 87.9677C404.832 88.4925 404.28 88.9464 403.674 89.3289C403.066 89.7113 402.443 89.9979 401.804 90.1889C401.164 90.3804 400.589 90.4276 400.078 90.3319C398.64 90.0458 397.537 89.424 396.77 88.4689C396.003 87.5137 395.515 86.3913 395.308 85.1017C395.1 83.8114 395.123 82.4338 395.38 80.969C395.635 79.5042 396.066 78.143 396.674 76.8848C397.281 75.6266 398.017 74.5436 398.879 73.6364C399.742 72.7285 400.685 72.1637 401.708 71.94C401.324 73.5642 401.197 75.2448 401.324 76.98C401.452 78.7157 401.868 80.3478 402.571 81.8762C403.018 82.8011 403.554 83.6441 404.177 84.4083C404.801 85.1732 405.56 85.8259 406.455 86.3671C406.199 86.9089 405.823 87.4422 405.328 87.9677ZM458.378 78.9151C458.474 78.183 458.617 77.4096 458.81 76.5975C459.001 75.786 459.241 74.9976 459.528 74.2333C459.816 73.4685 460.152 72.8079 460.536 72.2509C460.92 71.694 461.326 71.2952 461.758 71.0564C462.19 70.8176 462.629 70.8413 463.076 71.1279C463.556 71.4152 463.851 72.02 463.963 72.943C464.075 73.8673 463.963 74.8539 463.628 75.9054C463.292 76.9563 462.693 77.9436 461.83 78.8666C460.968 79.7914 459.8 80.3957 458.33 80.6823C458.266 80.2369 458.282 79.6478 458.378 78.9151ZM477.7 78.9151C477.796 78.183 477.939 77.4096 478.131 76.5975C478.323 75.786 478.563 74.9976 478.851 74.2333C479.138 73.4685 479.473 72.8079 479.857 72.2509C480.241 71.694 480.649 71.2952 481.08 71.0564C481.512 70.8176 481.951 70.8413 482.398 71.1279C482.878 71.4152 483.173 72.02 483.285 72.943C483.397 73.8673 483.285 74.8539 482.95 75.9054C482.614 76.9563 482.015 77.9436 481.152 78.8666C480.289 79.7914 479.122 80.3957 477.652 80.6823C477.588 80.2369 477.604 79.6478 477.7 78.9151ZM495.655 81.7096C495.287 81.312 494.84 81.0332 494.313 80.8732C493.785 80.7144 493.282 80.6987 492.802 80.826C492.323 80.9532 492.018 81.2878 491.891 81.829C491.635 82.8484 491.228 83.8914 490.669 84.9574C490.109 86.0253 489.422 87.0362 488.607 87.9913C487.792 88.9464 486.873 89.7913 485.851 90.5234C484.827 91.2561 483.757 91.7816 482.639 92.0991C481.519 92.4506 480.592 92.49 479.857 92.2191C479.122 91.9488 478.539 91.487 478.107 90.8343C477.676 90.181 477.365 89.3931 477.172 88.4689C476.981 87.5459 476.868 86.5907 476.837 85.6029C478.659 85.7307 480.281 85.4047 481.703 84.6235C483.125 83.8435 484.332 82.8077 485.324 81.5181C486.314 80.229 487.065 78.7799 487.576 77.1715C488.087 75.563 488.375 73.963 488.44 72.3703C488.471 70.8734 488.247 69.6073 487.768 68.5722C487.289 67.5377 486.642 66.7328 485.827 66.1601C485.011 65.5862 484.077 65.2522 483.021 65.1565C481.967 65.0607 480.896 65.205 479.809 65.5862C478.498 66.0328 477.388 66.7571 476.478 67.7601C475.567 68.7637 474.807 69.9267 474.2 71.2473C473.592 72.5697 473.113 73.9939 472.761 75.523C472.409 77.0515 472.154 78.5569 471.995 80.0375C471.839 81.4744 471.755 82.8496 471.736 84.1659C471.615 84.4283 471.486 84.692 471.347 84.9574C470.787 86.0253 470.1 87.0362 469.285 87.9913C468.471 88.9464 467.551 89.7913 466.529 90.5234C465.506 91.2561 464.435 91.7816 463.317 92.0991C462.197 92.4506 461.271 92.49 460.536 92.2191C459.8 91.9488 459.217 91.487 458.786 90.8343C458.355 90.181 458.043 89.3931 457.851 88.4689C457.659 87.5459 457.547 86.5907 457.515 85.6029C459.337 85.7307 460.959 85.4047 462.382 84.6235C463.803 83.8435 465.01 82.8077 466.001 81.5181C466.992 80.229 467.743 78.7799 468.254 77.1715C468.765 75.563 469.054 73.963 469.117 72.3703C469.149 70.8734 468.926 69.6073 468.447 68.5722C467.967 67.5377 467.319 66.7328 466.504 66.1601C465.689 65.5862 464.755 65.2522 463.7 65.1565C462.645 65.0607 461.574 65.205 460.488 65.5862C459.176 66.0328 458.066 66.7571 457.156 67.7601C456.245 68.7637 455.485 69.9267 454.878 71.2473C454.271 72.5697 453.792 73.9939 453.44 75.523C453.088 77.0515 452.832 78.5569 452.673 80.0375C452.582 80.8726 452.522 81.6823 452.477 82.4774C452.168 82.7393 451.867 83.0029 451.546 83.2617C450.444 84.1538 449.284 84.9574 448.07 85.6744C446.855 86.3913 445.592 86.9804 444.283 87.4422C442.971 87.904 441.629 88.1828 440.255 88.278L443.228 56.5578C443.42 55.8887 443.324 55.3003 442.94 54.7906C442.557 54.2809 442.061 53.9306 441.454 53.7397C440.847 53.5482 440.199 53.5645 439.512 53.787C438.824 54.0106 438.258 54.5203 437.81 55.3154C437.586 56.5263 437.354 58.182 437.115 60.2838C436.875 62.3856 436.635 64.6789 436.396 67.1631C436.156 69.6473 435.916 72.2109 435.677 74.8539C435.437 77.4981 435.229 79.966 435.053 82.2587C435.045 82.3605 435.039 82.4526 435.031 82.5532C434.751 82.7896 434.48 83.0277 434.19 83.2617C433.088 84.1538 431.928 84.9574 430.714 85.6744C429.499 86.3913 428.237 86.9804 426.927 87.4422C425.616 87.904 424.273 88.1828 422.899 88.278L425.872 56.5578C426.064 55.8887 425.968 55.3003 425.585 54.7906C425.201 54.2809 424.705 53.9306 424.098 53.7397C423.491 53.5482 422.843 53.5645 422.156 53.787C421.469 54.0106 420.902 54.5203 420.454 55.3154C420.23 56.5263 419.999 58.182 419.76 60.2838C419.519 62.3856 419.28 64.6789 419.04 67.1631C418.8 69.6473 418.561 72.2109 418.321 74.8539C418.082 77.4981 417.873 79.966 417.698 82.2587C417.694 82.3047 417.691 82.3465 417.687 82.3926C417.185 82.6247 416.638 82.8284 416.043 82.9993C415.436 83.175 414.749 83.2786 413.982 83.3102C414.11 82.7362 414.213 82.0993 414.293 81.3987C414.373 80.6987 414.438 79.966 414.486 79.2011C414.534 78.4375 414.549 77.6727 414.534 76.9084C414.517 76.1436 414.477 75.4436 414.414 74.806C414.253 73.4376 413.958 72.1394 413.527 70.9128C413.095 69.6873 412.512 68.6607 411.777 67.8316C411.041 67.0037 410.123 66.4462 409.019 66.1601C407.917 65.8734 406.63 65.9686 405.161 66.4462C402.986 66.1601 401.029 66.3595 399.287 67.0437C397.545 67.7292 396.034 68.7237 394.756 70.0291C393.478 71.3358 392.431 72.8715 391.616 74.6394C390.801 76.4066 390.257 78.2224 389.986 80.0848C389.871 80.8744 389.815 81.6605 389.798 82.4447C389.303 83.4544 388.761 84.3368 388.164 85.0774C387.317 86.1283 386.438 86.9883 385.527 87.6568C384.616 88.3258 383.713 88.8355 382.819 89.1858C381.923 89.5367 381.124 89.7755 380.421 89.9022C379.59 90.0616 378.791 90.0779 378.024 89.9501C377.257 89.8234 376.553 89.4567 375.915 88.8513C375.403 88.4058 375.011 87.6889 374.74 86.7016C374.468 85.7144 374.309 84.5926 374.261 83.3338C374.213 82.0756 374.261 80.7617 374.404 79.3926C374.548 78.0236 374.795 76.7254 375.147 75.4994C375.499 74.2733 375.945 73.1746 376.49 72.2024C377.032 71.2322 377.672 70.5388 378.408 70.1249C378.822 70.1891 379.079 70.4352 379.175 70.8649C379.271 71.2952 379.294 71.8049 379.246 72.394C379.199 72.9836 379.127 73.5885 379.031 74.2091C378.935 74.8303 378.887 75.3485 378.887 75.7618C379.047 76.6218 379.358 77.2909 379.822 77.7684C380.285 78.246 380.805 78.5254 381.38 78.6042C381.955 78.6842 382.522 78.549 383.083 78.1981C383.641 77.8484 384.096 77.2909 384.449 76.526C384.48 76.5581 384.528 76.5739 384.592 76.5739L385.264 70.5073C385.455 69.6788 385.327 68.9467 384.88 68.3098C384.432 67.6728 383.841 67.3062 383.106 67.211C382.179 65.8734 380.924 65.165 379.342 65.085C377.76 65.0056 376.138 65.5231 374.476 66.6377C373.453 67.371 372.55 68.3813 371.767 69.671C370.983 70.9613 370.345 72.394 369.85 73.9703C369.353 75.5466 369.002 77.2115 368.795 78.963C368.587 80.7144 368.547 82.4187 368.674 84.0738C368.802 85.7307 369.098 87.2913 369.562 88.7555C370.025 90.221 370.672 91.447 371.504 92.4337C372.207 93.2937 373.005 93.9233 373.9 94.3215C374.795 94.7197 375.73 94.9658 376.705 95.0615C377.68 95.1567 378.647 95.1167 379.606 94.9421C380.565 94.7676 381.476 94.5209 382.339 94.2015C383.457 93.7882 384.609 93.2621 385.791 92.6252C386.973 91.9888 388.108 91.224 389.195 90.3319C389.767 89.8628 390.317 89.3513 390.849 88.8028C391.091 89.4016 391.362 89.981 391.688 90.5234C392.551 91.9561 393.717 93.1191 395.188 94.0106C396.657 94.9021 398.464 95.3312 400.605 95.3003C402.907 95.2682 405.032 94.6876 406.982 93.5567C408.932 92.427 410.53 90.7616 411.777 88.5646C413.644 88.5646 415.481 88.258 417.287 87.6489C417.272 87.8416 417.256 88.0446 417.242 88.2307C417.115 89.9186 417.05 91.0646 417.05 91.67C417.019 92.7209 416.947 94.0185 416.835 95.5627C416.723 97.1075 416.651 98.7318 416.619 100.435C416.588 102.139 416.651 103.859 416.811 105.595C416.971 107.33 417.306 108.907 417.818 110.325C418.328 111.741 419.055 112.944 419.999 113.932C420.941 114.918 422.18 115.508 423.715 115.699C425.345 115.921 426.751 115.635 427.934 114.839C429.116 114.042 430.075 112.952 430.811 111.567C431.546 110.181 432.064 108.581 432.369 106.766C432.672 104.95 432.76 103.127 432.633 101.295C432.504 99.4639 432.168 97.7366 431.625 96.113C431.082 94.4882 430.33 93.1506 429.372 92.0991C429.948 91.9409 430.634 91.6385 431.434 91.1919C432.232 90.7464 433.055 90.2446 433.903 89.687C434.111 89.5501 434.316 89.4058 434.524 89.2652C434.446 90.3937 434.406 91.1985 434.406 91.67C434.375 92.7209 434.303 94.0185 434.19 95.5627C434.079 97.1075 434.007 98.7318 433.975 100.435C433.943 102.139 434.007 103.859 434.167 105.595C434.326 107.33 434.662 108.907 435.173 110.325C435.684 111.741 436.412 112.944 437.354 113.932C438.297 114.918 439.536 115.508 441.071 115.699C442.7 115.921 444.106 115.635 445.289 114.839C446.472 114.042 447.431 112.952 448.166 111.567C448.901 110.181 449.42 108.581 449.724 106.766C450.028 104.95 450.115 103.127 449.988 101.295C449.86 99.4639 449.524 97.7366 448.982 96.113C448.437 94.4882 447.687 93.1506 446.727 92.0991C447.303 91.9409 447.99 91.6385 448.789 91.1919C449.588 90.7464 450.411 90.2446 451.259 89.687C451.699 89.3974 452.136 89.0986 452.573 88.7913C452.737 90.3488 453.091 91.7149 453.655 92.864C454.343 94.2658 455.277 95.3482 456.46 96.113C457.642 96.8766 459.033 97.299 460.632 97.3784C462.23 97.4572 463.971 97.1633 465.858 96.4942C467.264 95.9851 468.486 95.3482 469.525 94.5839C470.563 93.8191 471.498 92.8876 472.33 91.7894C472.378 91.7258 472.423 91.6567 472.47 91.5925C472.618 92.0385 472.782 92.467 472.977 92.864C473.665 94.2658 474.6 95.3482 475.782 96.113C476.964 96.8766 478.355 97.299 479.953 97.3784C481.551 97.4572 483.293 97.1633 485.179 96.4942C486.586 95.9851 487.808 95.3482 488.847 94.5839C489.885 93.8191 490.82 92.8876 491.652 91.7894C492.483 90.6901 493.241 89.424 493.929 87.9913C494.616 86.558 495.311 84.9186 496.015 83.0708C496.142 82.5617 496.022 82.1078 495.655 81.7096Z" fill="#0D0C23"/>\n</svg>';

// src/Storage/Storage.ts
var Storage = class {
  constructor(data) {
    this.set(data);
  }
  get(k) {
    return this.item.get(k);
  }
  set(value) {
    this.item = new StorageObjectItem(value);
  }
  collect() {
    return this.item.value();
  }
};
var create = (value) => {
  if (typeof value === "object" && !Array.isArray(value) && value !== null) {
    return new StorageObjectItem(value);
  } else {
    return new StoragePrimitiveItem(value);
  }
};
var StorageObjectItem = class {
  constructor(data) {
    this.items = null;
    this.set(data);
  }
  add(key, value) {
    this.items[key] = create(value);
    return this.get(key);
  }
  get(key) {
    return this.items[key];
  }
  set(value) {
    this.items = {};
    for (const [key, v] of ObjectHelper.entries(value)) {
      this.items[key] = create(v);
    }
  }
  value() {
    const data = {};
    for (const [k, v] of ObjectHelper.entries(this.items)) {
      data[k] = v.value();
    }
    return data;
  }
};
var StoragePrimitiveItem = class {
  constructor(data) {
    this.data = data;
  }
  value() {
    return this.data;
  }
  set(value) {
    this.data = value;
  }
};

// src/Creator/Template/Factory.ts
var Factory = class {
  constructor(pattern, factory) {
    this.pattern = pattern;
    this.factory = factory;
  }
  create(template) {
    const type = new RegExp(this.pattern).test(template) ? "composite" : "simple";
    const obj = this.factory(type);
    obj.setTemplate(template);
    return obj;
  }
};
Factory = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["template:pattern"])),
  __decorateParam(1, inject(inversify_types_default["factory:template:resolver"]))
], Factory);

// src/Creator/Template/Simple.ts
var Simple = class {
  constructor(factory) {
    this.factory = factory;
    this.placeholder = null;
  }
  getPlaceholders() {
    if (this.placeholder === null) {
      this.placeholder = this.factory.create(this.template);
    }
    return [this.placeholder];
  }
  getTemplate() {
    return this.template;
  }
  setTemplate(template) {
    this.template = template;
  }
};
Simple = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:placeholder"]))
], Simple);

// src/Creator/Template/Placeholders/AbstractPlaceholder.ts
var AbstractPlaceholder = class {
  getPlaceholder() {
    return this.placeholder;
  }
};
AbstractPlaceholder = __decorateClass([
  injectable()
], AbstractPlaceholder);

// src/Creator/Template/Placeholders/MetaPlaceholder.ts
var MetaPlaceholder = class extends AbstractPlaceholder {
  constructor(extractor, factory) {
    super();
    this.extractor = extractor;
    this.factory = factory;
  }
  makeValue(path) {
    return this.extractor.extract(this.placeholder, this.factory(path, "frontmatter"));
  }
  setPlaceholder(placeholder) {
    this.placeholder = placeholder;
  }
};
MetaPlaceholder = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["component:extractor"])),
  __decorateParam(1, inject(inversify_types_default["factory:obsidian:meta"]))
], MetaPlaceholder);

// src/Components/Extractor/Exceptions/PathNotFoundException.ts
var PathNotFoundException = class extends Error {
};

// src/Components/Extractor/Exceptions/TypeNotSupportedException.ts
var TypeNotSupportedException = class extends Error {
};

// src/Creator/Creator.ts
var Creator = class {
  constructor(factory, logger) {
    this.factory = factory;
    this.logger = logger;
    this.cache = /* @__PURE__ */ new Map();
  }
  pull(template) {
    const key = `template:${template}`;
    if (this.cache.has(key) === false) {
      this.logger.log(`Create template fo ${template}`);
      this.cache.set(key, this.factory.create(template));
    }
    return this.cache.get(key);
  }
  create(path, template) {
    var _a, _b;
    for (const placeholder of this.pull(template).getPlaceholders()) {
      let value = "";
      try {
        value = (_a = placeholder.makeValue(path)) != null ? _a : "";
      } catch (e) {
        if (e instanceof PathNotFoundException || e instanceof TypeNotSupportedException) {
          this.logger.log(`Error by path: ${path}. ${e.message}`);
        } else {
          throw e;
        }
      }
      template = template.replace(placeholder.getPlaceholder(), value);
    }
    if ((_b = template == null ? void 0 : template.trim()) == null ? void 0 : _b.length) {
      return template.trim();
    }
    return null;
  }
};
Creator = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:creator:template"])),
  __decorateParam(1, inject(inversify_types_default.logger)),
  __decorateParam(1, named("creator"))
], Creator);

// src/Creator/Template/Placeholders/Factory.ts
var Factory2 = class {
  constructor(factory) {
    this.factory = factory;
  }
  create(placeholder) {
    let type = "meta";
    if (placeholder.startsWith("{{") && placeholder.endsWith("}}")) {
      type = "brackets";
    } else if (placeholder.startsWith("_")) {
      type = "file";
    } else if (placeholder === "#heading") {
      type = "heading";
    }
    return this.factory(type, placeholder);
  }
};
Factory2 = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:placeholder:resolver"]))
], Factory2);

// src/Creator/Template/Composite.ts
var Composite = class {
  constructor(pattern, factory) {
    this.pattern = pattern;
    this.factory = factory;
    this.placeholders = [];
  }
  getPlaceholders() {
    if (this.placeholders.length === 0) {
      const parts = this.template.match(new RegExp(this.pattern, "g"));
      for (const part of parts) {
        const {
          groups: { placeholder }
        } = part.match(this.pattern);
        this.placeholders.push(this.factory.create(placeholder));
      }
    }
    return this.placeholders;
  }
  getTemplate() {
    return this.template;
  }
  setTemplate(template) {
    this.template = template;
  }
};
Composite = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["template:pattern"])),
  __decorateParam(1, inject(inversify_types_default["factory:placeholder"]))
], Composite);

// src/Creator/Template/Placeholders/BracketsPlaceholder.ts
var BracketsPlaceholder = class {
  constructor(factory) {
    this.factory = factory;
  }
  getPlaceholder() {
    return this.placeholder;
  }
  makeValue(path) {
    return this.child.makeValue(path);
  }
  setPlaceholder(placeholder) {
    this.placeholder = placeholder;
    const {
      groups: { inside }
    } = this.placeholder.match(new RegExp(`^{{(?<inside>.*?)}}`));
    this.child = this.factory.create(inside);
  }
};
BracketsPlaceholder = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:placeholder"]))
], BracketsPlaceholder);

// src/Creator/Template/Placeholders/FilePlaceholder.ts
var FilePlaceholder = class extends AbstractPlaceholder {
  constructor(extractor, factory) {
    super();
    this.extractor = extractor;
    this.factory = factory;
  }
  makeValue(path) {
    return this.extractor.extract(this.path, this.factory(path));
  }
  setPlaceholder(placeholder) {
    this.placeholder = placeholder;
    this.path = placeholder.substring(1);
  }
};
FilePlaceholder = __decorateClass([
  __decorateParam(0, inject(inversify_types_default["component:extractor"])),
  __decorateParam(1, inject(inversify_types_default["factory:obsidian:file"]))
], FilePlaceholder);

// src/Creator/Template/Placeholders/HeadingPlaceholder.ts
var HeadingPlaceholder = class {
  constructor(factory) {
    this.factory = factory;
  }
  getPlaceholder() {
    return this.placeholder;
  }
  makeValue(path) {
    var _a, _b, _c;
    return (_c = (_b = (_a = this.factory(path, "headings")) == null ? void 0 : _a[0]) == null ? void 0 : _b.heading) != null ? _c : "";
  }
  setPlaceholder(placeholder) {
    this.placeholder = placeholder;
  }
};
HeadingPlaceholder = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:obsidian:meta"]))
], HeadingPlaceholder);

// config/services/creator.config.ts
var creator_config_default = new ContainerModule((bind) => {
  bind(inversify_types_default["factory:creator:template"]).to(Factory);
  bind(inversify_types_default["factory:template:resolver"]).toAutoNamedFactory(
    inversify_types_default["creator:template"]
  );
  bind(inversify_types_default["creator:template"]).to(Simple).whenTargetNamed("simple");
  bind(inversify_types_default["creator:template"]).to(Composite).whenTargetNamed("composite");
  bind(inversify_types_default.placeholder).to(MetaPlaceholder).whenTargetNamed("meta");
  bind(inversify_types_default.placeholder).to(FilePlaceholder).whenTargetNamed("file");
  bind(inversify_types_default.placeholder).to(BracketsPlaceholder).whenTargetNamed("brackets");
  bind(inversify_types_default.placeholder).to(HeadingPlaceholder).whenTargetNamed("heading");
  bind(inversify_types_default["creator:creator"]).to(Creator);
  bind(inversify_types_default["factory:placeholder:resolver"]).toFactory((context) => (type, placeholder) => {
    const item = context.container.getNamed(inversify_types_default.placeholder, type);
    item.setPlaceholder(placeholder);
    return item;
  });
  bind(inversify_types_default["getter:delimiter"]).toDynamicValue((c) => () => c.container.get(inversify_types_default.delimiter));
  bind(inversify_types_default["factory:placeholder"]).to(Factory2).inSingletonScope();
});

// src/Feature/AbstractFeature.ts
var AbstractFeature = class {
  static getId() {
    throw new Error("Static function 'getId()' is not implemented");
  }
};
AbstractFeature = __decorateClass([
  injectable()
], AbstractFeature);

// src/Feature/AbstractManager.ts
var AbstractManager = class extends AbstractFeature {
  disable() {
    this.isEnabled() && this.doDisable();
  }
  enable() {
    !this.isEnabled() && this.doEnable();
  }
  async update(path) {
    if (!this.isEnabled()) {
      return false;
    }
    return this.doUpdate(path);
  }
  async refresh() {
    if (this.isEnabled()) {
      return this.doRefresh();
    }
  }
  setResolver(resolver) {
    this.resolver = resolver;
  }
};
AbstractManager = __decorateClass([
  injectable()
], AbstractManager);

// src/Feature/Explorer/ExplorerViewUndefined.ts
var ExplorerViewUndefined = class extends Error {
};

// src/Feature/Explorer/ExplorerManager.ts
var ExplorerManager = class extends AbstractManager {
  constructor(facade) {
    super();
    this.facade = facade;
    this.explorerView = null;
    this.originTitles = /* @__PURE__ */ new Map();
    this.enabled = false;
    this.isTitleEmpty = (title) => title === null || title === "" || title === void 0;
  }
  getId() {
    return "explorer" /* Explorer */;
  }
  isEnabled() {
    return this.enabled;
  }
  doDisable() {
    if (this.explorerView) {
      this.restoreTitles();
      this.explorerView = null;
    }
    this.enabled = false;
  }
  doEnable() {
    this.explorerView = this.getExplorerView();
    this.enabled = true;
  }
  getFileItemInnerTitleEl(fileItem) {
    var _a;
    return (_a = fileItem.titleInnerEl) != null ? _a : fileItem.innerEl;
  }
  getExplorerView() {
    var _a;
    const leaves = this.facade.getLeavesOfType("file-explorer" /* FE */);
    if (leaves.length > 1) {
      throw new Error("There are some explorers' leaves");
    }
    const view = (_a = leaves == null ? void 0 : leaves[0]) == null ? void 0 : _a.view;
    if (view === void 0) {
      throw new ExplorerViewUndefined("Explorer view is undefined");
    }
    return view;
  }
  async updateInternal(items) {
    if (!items.filter((e) => e).length) {
      return {};
    }
    const result = {};
    const promises = items.map((e) => this.setTitle(e).then((r) => result[e.file.path] = r));
    await Promise.all(promises);
    return result;
  }
  async setTitle(item) {
    const title = await (async () => this.resolver.resolve(item.file.path))().catch(() => null);
    if (this.isTitleEmpty(title)) {
      return this.restore(item);
    } else if (this.getFileItemInnerTitleEl(item).innerText !== title) {
      this.keepOrigin(item);
      this.getFileItemInnerTitleEl(item).innerText = title;
      return true;
    }
    return false;
  }
  keepOrigin(item) {
    if (!this.originTitles.has(item.file.path)) {
      this.originTitles.set(item.file.path, this.getFileItemInnerTitleEl(item).innerText);
    }
  }
  restoreTitles() {
    Object.values(this.explorerView.fileItems).map(this.restore.bind(this));
  }
  restore(item) {
    if (this.originTitles.has(item.file.path)) {
      this.getFileItemInnerTitleEl(item).innerText = this.originTitles.get(item.file.path);
      this.originTitles.delete(item.file.path);
      return true;
    }
    return false;
  }
  doRefresh() {
    return this.updateInternal(Object.values(this.explorerView.fileItems));
  }
  async doUpdate(path) {
    const item = this.explorerView.fileItems[path];
    const result = await this.updateInternal(item ? [item] : []);
    return result[path] === true;
  }
  static getId() {
    return "explorer" /* Explorer */;
  }
};
ExplorerManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["facade:obsidian"]))
], ExplorerManager);

// src/Feature/FeatureComposer.ts
var FeatureComposer = class {
  constructor(factory, dispatcher, logger) {
    this.factory = factory;
    this.dispatcher = dispatcher;
    this.logger = logger;
    this.features = {};
  }
  get(id3) {
    var _a;
    return (_a = this.features[id3]) != null ? _a : null;
  }
  getIds() {
    return Object.keys(this.features);
  }
  toggle(id3, state) {
    const feature = this.features[id3];
    if (!state && !feature || state && (feature == null ? void 0 : feature.isEnabled())) {
      return;
    }
    if (!feature) {
      this.features[id3] = this.factory(id3);
      return this.toggle(id3, state);
    }
    feature[state ? "enable" : "disable"]();
    this.logger.log(`Feature - ${feature.getId()}. State: ${state}`);
    if (!state) {
      delete this.features[id3];
    } else {
      this.dispatcher.dispatch("feature:enable", new Event({ feature }));
    }
  }
  disableAll() {
    for (const feature of Object.values(this.features)) {
      this.logger.log(`Disable feature ${feature.getId()}`);
      feature.disable();
    }
    this.features = {};
  }
};
FeatureComposer = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:feature"])),
  __decorateParam(1, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(2, inject(inversify_types_default.logger)),
  __decorateParam(2, named("composer:feature"))
], FeatureComposer);

// src/Utils/FunctionReplacer.ts
var FunctionReplacer = class _FunctionReplacer {
  constructor(target, method, args, implementation) {
    this.target = target;
    this.method = method;
    this.args = args;
    this.implementation = implementation;
    this.vanilla = null;
    this.valid();
  }
  getTarget() {
    return this.target;
  }
  valid() {
    if (typeof this.target[this.method] !== "function") {
      throw new Error(`Method ${this.method} is not a function`);
    }
  }
  enable() {
    if (this.vanilla !== null) {
      return false;
    }
    const self2 = this;
    this.vanilla = this.target[this.method];
    this.target[this.method] = function(...args) {
      return self2.implementation.call(this, self2.args, args, self2.vanilla);
    };
    return true;
  }
  disable() {
    if (this.vanilla !== null) {
      this.target[this.method] = this.vanilla;
      this.vanilla = null;
    }
  }
  isEnabled() {
    return this.vanilla !== null;
  }
  static create(target, method, args, implementation) {
    return new _FunctionReplacer(target, method, args, implementation);
  }
};

// src/Feature/Explorer/ExplorerSort.ts
var import_obsidian3 = require("obsidian");
var ExplorerSort = class extends AbstractFeature {
  constructor(logger, facade, dispatcher, service) {
    super();
    this.logger = logger;
    this.facade = facade;
    this.dispatcher = dispatcher;
    this.enabled = false;
    this.refs = [];
    this.resolver = service.createResolver("explorer" /* Explorer */);
    const trigger = (0, import_obsidian3.debounce)(this.onManagerUpdate.bind(this), 1e3);
    this.cb = (e) => {
      if (e.id === "explorer" /* Explorer */ && (e.result === true || e.result === void 0)) {
        trigger();
      }
    };
  }
  onManagerUpdate() {
    this.logger.log("Try to request sort by event");
    if (!this.isEnabled()) {
      this.logger.log("Skipped because feature is not enabled");
      return;
    }
    this.view.requestSort();
  }
  static getId() {
    return "explorer:sort" /* ExplorerSort */;
  }
  initView() {
    var _a, _b, _c;
    this.view = (_c = (_b = (_a = this.facade.getLeavesOfType("file-explorer" /* FE */)) == null ? void 0 : _a[0]) == null ? void 0 : _b.view) != null ? _c : null;
  }
  tryToReplaceOriginalSort() {
    if (!this.isEnabled()) {
      return;
    }
    if (this.replacer) {
      this.logger.log(`Replacer is exist already. State is ${this.replacer.isEnabled()}`);
      if (!this.replacer.isEnabled()) {
        this.logger.log("Enable replacer");
        this.replacer.enable();
      }
      return;
    }
    const item = this.getFolderItem();
    if (!item) {
      this.logger.log("Folder item not found. Try again in 1000 ms");
      setTimeout(() => this.tryToReplaceOriginalSort(), 1e3);
      return;
    }
    this.logger.log("Init replacer");
    this.replacer = new FunctionReplacer(
      //@ts-ignore
      item.__proto__,
      "sort",
      this,
      function(args, defaultArgs, vanilla) {
        args.sort(this, vanilla);
      }
    );
    this.replacer.enable();
  }
  isSortSupported(sort) {
    return ["alphabeticalReverse", "alphabetical"].includes(sort);
  }
  isAsc(order) {
    return order === "alphabetical";
  }
  sort(item, vanilla) {
    const sortOrder = this.view.sortOrder;
    if (!this.isSortSupported(sortOrder)) {
      this.logger.log(`Sort is ${sortOrder}. Skipped.`);
      vanilla.call(item);
      return;
    }
    if (!(item.file instanceof import_obsidian3.TFolder)) {
      this.logger.log("File is not TFolder. Why? Skipped.");
      vanilla.call(item);
      return;
    }
    this.logger.log("Sort by feature");
    const children = item.file.children.slice();
    const result = [];
    children.sort((a, b) => {
      var _a, _b;
      const i = a instanceof import_obsidian3.TFolder;
      const r = b instanceof import_obsidian3.TFolder;
      let k;
      if (i && !r) {
        k = -1;
      } else if (!i && r) {
        k = 1;
      } else {
        const at = i ? a.name : (_a = this.resolver.resolve(a.path)) != null ? _a : a.name;
        const bt = r ? b.name : (_b = this.resolver.resolve(b.path)) != null ? _b : b.name;
        k = at.localeCompare(bt);
        k = this.isAsc(sortOrder) ? k : -k;
      }
      return k;
    });
    for (const child of children) {
      const f = this.view.fileItems[child.path];
      f && result.push(f);
    }
    item.vChildren.setChildren(result);
  }
  getFolderItem() {
    for (const item of Object.values(this.view.fileItems)) {
      if (item.file instanceof import_obsidian3.TFolder) {
        return item;
      }
    }
  }
  async enable() {
    if (this.isEnabled()) {
      return;
    }
    if (!this.view && (this.initView(), !this.view)) {
      throw new ExplorerViewUndefined();
    }
    this.refs.push(this.dispatcher.addListener({ name: "manager:refresh", cb: (e) => this.cb({ id: e.get().id }) }));
    this.refs.push(
      this.dispatcher.addListener({
        name: "manager:update",
        cb: (e) => this.cb(e.get())
      })
    );
    this.enabled = true;
    this.tryToReplaceOriginalSort();
    this.logger.log("enabled");
  }
  async disable() {
    var _a, _b;
    this.enabled = false;
    this.refs.forEach((e) => this.dispatcher.removeListener(e));
    this.refs = [];
    (_a = this.replacer) == null ? void 0 : _a.disable();
    (_b = this.view) == null ? void 0 : _b.requestSort();
    this.logger.log("disabled");
  }
  isEnabled() {
    return this.enabled;
  }
  getId() {
    return "explorer:sort" /* ExplorerSort */;
  }
};
ExplorerSort = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default.logger)),
  __decorateParam(0, named("explorer:feature:sort")),
  __decorateParam(1, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(2, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(3, inject(inversify_types_default["feature:service"]))
], ExplorerSort);

// src/Feature/ManagerComposer.ts
var ManagerComposer = class {
  constructor(features, logger, dispatcher) {
    this.features = features;
    this.logger = logger;
    this.dispatcher = dispatcher;
    this.ids = Managers;
  }
  async update(path, id3 = null) {
    const ids = id3 ? [id3] : this.ids;
    const result = {};
    const promises = [];
    for (const i of ids) {
      const manager = this.features.get(i);
      if (manager) {
        this.logger.log(`Run update for [${path}] on [${manager.getId()}]`);
        promises.push(
          manager.update(path).then((r) => {
            result[i] = r;
            this.dispatcher.dispatch("manager:update", new Event({ id: i, result: r, path }));
          })
        );
      }
    }
    await Promise.all(promises);
    return result;
  }
  async refresh(id3 = null) {
    this.logger.log("refresh");
    const ids = id3 ? [id3] : this.ids;
    const promises = [];
    for (const i of ids) {
      const manager = this.features.get(i);
      if (manager) {
        promises.push(
          manager.refresh().then(() => this.dispatcher.dispatch("manager:refresh", new Event({ id: i })))
        );
      }
    }
    await Promise.all(promises);
  }
};
ManagerComposer = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["feature:composer"])),
  __decorateParam(1, inject(inversify_types_default.logger)),
  __decorateParam(1, named("composer:manager")),
  __decorateParam(2, inject(inversify_types_default["event:dispatcher"]))
], ManagerComposer);

// src/Feature/Search/SearchFeature.ts
var SearchManager = class extends AbstractFeature {
  constructor(facade, logger, service, featureService) {
    super();
    this.facade = facade;
    this.logger = logger;
    this.service = service;
    this.enabled = false;
    this.dom = null;
    this.resolver = featureService.createResolver(this.getId());
  }
  getView() {
    var _a, _b;
    return (_b = (_a = this.facade.getViewsOfType("search" /* S */)) == null ? void 0 : _a[0]) != null ? _b : null;
  }
  getSearchDom() {
    var _a, _b;
    if (!this.dom) {
      this.dom = (_b = (_a = this.getView()) == null ? void 0 : _a.dom) != null ? _b : null;
    }
    return this.dom;
  }
  disable() {
    this.dom = null;
    this.service.destroyByTag(this.getId());
    this.enabled = false;
  }
  enable() {
    const dom = this.getSearchDom();
    if (!dom) {
      throw new Error(`View of ${"search" /* S */} not found`);
    }
    this.service.wrapDom(dom, this.resolver, this.getId());
    this.enabled = true;
  }
  static getId() {
    return "search" /* Search */;
  }
  getId() {
    return SearchManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
SearchManager = __decorateClass([
  __decorateParam(0, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(1, inject(inversify_types_default.logger)),
  __decorateParam(1, named("manager:starred")),
  __decorateParam(2, inject(inversify_types_default["service:search:dom:wrapper"])),
  __decorateParam(3, inject(inversify_types_default["feature:service"]))
], SearchManager);

// src/Feature/Tab/TabManager.ts
var TabManager = class extends AbstractManager {
  constructor(facade, dispatcher, factory) {
    super();
    this.facade = facade;
    this.dispatcher = dispatcher;
    this.enabled = false;
    this.callback = null;
    this.replacer = null;
    this.callback = () => {
      const file = factory();
      file && this.update(file.path);
    };
  }
  async doDisable() {
    var _a;
    this.dispatcher.removeListener(this.ref);
    (_a = this.replacer) == null ? void 0 : _a.disable();
    this.ref = null;
    this.reset();
    this.enabled = false;
  }
  async doEnable() {
    this.enabled = true;
    this.initReplacer();
    this.ref = this.dispatcher.addListener({ name: "layout:change", cb: this.callback });
    return;
  }
  initReplacer() {
    const leaf = this.facade.getActiveLeaf();
    this.replacer = FunctionReplacer.create(
      Object.getPrototypeOf(leaf),
      "setPinned",
      this,
      function(self2, [pinned], vanilla) {
        var _a;
        const result = vanilla.call(this, pinned);
        if (((_a = this == null ? void 0 : this.view) == null ? void 0 : _a.getViewType()) === "markdown" /* MD */) {
          self2.innerUpdate(this.view.file.path);
        }
        return result;
      }
    );
    this.replacer.enable();
  }
  reset() {
    var _a;
    const leaves = this.facade.getLeavesOfType("markdown");
    for (const leaf of leaves) {
      const file = (_a = leaf.view) == null ? void 0 : _a.file;
      if (file) {
        leaf.tabHeaderInnerTitleEl.setText(file.basename);
      }
    }
  }
  async innerUpdate(path = null) {
    var _a;
    const leaves = this.facade.getLeavesOfType("markdown");
    const result = {};
    for (const leaf of leaves) {
      const file = (_a = leaf.view) == null ? void 0 : _a.file;
      if (path && path !== file.path) {
        continue;
      }
      result[file.path] = false;
      const title = file ? this.resolver.resolve(file.path) : null;
      if (title && title !== leaf.tabHeaderInnerTitleEl.getText()) {
        leaf.tabHeaderInnerTitleEl.setText(title);
        result[file.path] = true;
      }
    }
    return result;
  }
  async doRefresh() {
    return this.innerUpdate();
  }
  async doUpdate(path) {
    const result = await this.innerUpdate(path);
    return result[path] === true;
  }
  static getId() {
    return "tab" /* Tab */;
  }
  getId() {
    return TabManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
TabManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(1, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(2, inject(inversify_types_default["factory:obsidian:active:file"]))
], TabManager);

// src/Feature/Alias/Alias.ts
var Alias = class {
  constructor(cache) {
    this.cache = cache;
    this.changed = false;
    this.original = void 0;
  }
  getPossibleKeys() {
    return ["alias", "aliases"];
  }
  getKey() {
    for (const key of Object.keys(this.cache)) {
      if (this.getPossibleKeys().includes(key)) {
        return key;
      }
    }
    return null;
  }
  getValue() {
    var _a;
    return (_a = this.cache[this.getKey()]) != null ? _a : null;
  }
  setValue(alias) {
    if (this.original === void 0) {
      const value = this.getValue();
      this.original = {
        value: Array.isArray(value) ? [...value] : value,
        key: this.getKey()
      };
    }
    this.modify(alias);
    this.changed = true;
  }
  isChanged() {
    return this.changed;
  }
  restore() {
    const key = this.getKey();
    if (this.original.key === null && key) {
      delete this.cache[key];
    } else if (this.original.key) {
      this.modify(this.original.value);
    }
    this.changed = false;
  }
  modify(alias) {
    var _a;
    const key = (_a = this.getKey()) != null ? _a : this.getPossibleKeys()[0];
    this.cache[key] = alias;
  }
};

// src/Feature/Alias/AliasFeature.ts
var AliasFeature = class extends AbstractFeature {
  constructor(strategyFactory, validatorFactory, logger, factory, dispatcher, config) {
    super();
    this.strategyFactory = strategyFactory;
    this.validatorFactory = validatorFactory;
    this.logger = logger;
    this.factory = factory;
    this.dispatcher = dispatcher;
    this.config = config;
    this.enabled = false;
    this.strategy = null;
    this.validator = null;
    this.items = {};
    this.ref = null;
  }
  setValidator(type) {
    this.validator = this.validatorFactory(type);
    this.logger.log(`Set validator [${type}]. Status: ${this.validator !== null}`);
  }
  setStrategy(type) {
    this.strategy = this.strategyFactory(type);
    this.logger.log(`Set strategy [${type}]. Status: ${this.strategy !== null}`);
  }
  disable() {
    this.reset();
    this.dispatcher.removeListener(this.ref);
    this.ref = null;
    this.enabled = false;
  }
  enable() {
    this.ref = this.dispatcher.addListener({
      name: "metadata:cache:changed",
      cb: (e) => this.update(e.get().path, e.get().cache)
    });
    this.setValidator(this.config.getValidator());
    this.setStrategy(this.config.getStrategy());
    this.enabled = true;
    this.refresh().catch(console.error);
  }
  process(frontmatter, path) {
    const alias = new Alias(frontmatter);
    this.strategy.process(alias, path);
    const result = alias.isChanged();
    if (result) {
      this.items[path] = alias;
    }
    return result;
  }
  reset() {
    for (const alias of Object.values(this.items)) {
      alias.restore();
    }
    this.items = {};
  }
  async update(path, metadata = null) {
    if (this.validator.validate(metadata)) {
      this.process(metadata.frontmatter, path);
    }
  }
  async refresh() {
    const cache = this.factory();
    const promises = [];
    for (const path of cache.getCachedFiles()) {
      promises.push(this.update(path, cache.getCache(path)));
    }
    await Promise.all(promises);
  }
  static getId() {
    return "alias" /* Alias */;
  }
  getId() {
    return AliasFeature.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
AliasFeature = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:alias:modifier:strategy"])),
  __decorateParam(1, inject(inversify_types_default["factory:alias:modifier:validator"])),
  __decorateParam(2, inject(inversify_types_default.logger)),
  __decorateParam(2, named("alias:modifier")),
  __decorateParam(3, inject(inversify_types_default["factory:metadata:cache"])),
  __decorateParam(4, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(5, inject(inversify_types_default["feature:alias:config"]))
], AliasFeature);

// src/Feature/Alias/Strategy/AbstractStrategy.ts
var AbstractStrategy = class {
  constructor(service) {
    this.service = service;
    this.resolver = service.createResolver("alias" /* Alias */);
  }
  process(alias, path) {
    const title = this.resolver.resolve(path);
    if (title) {
      this.modify(alias, title);
    }
  }
};
AbstractStrategy = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["feature:service"]))
], AbstractStrategy);

// src/Feature/Alias/Strategy/ReplaceStrategy.ts
var ReplaceStrategy = class extends AbstractStrategy {
  modify(alias, title) {
    alias.setValue(title);
  }
};

// src/Feature/Alias/Strategy/EnsureStrategy.ts
var EnsureStrategy = class extends ReplaceStrategy {
  process(alias, path) {
    if (alias.getValue() === null) {
      super.process(alias, path);
    }
  }
};

// src/Feature/Alias/Strategy/AdjustStrategy.ts
var AdjustStrategy = class extends AbstractStrategy {
  modify(alias, title) {
    var _a;
    let value = (_a = alias.getValue()) != null ? _a : [];
    if (!Array.isArray(value)) {
      value = [value];
    }
    value.push(title);
    alias.setValue(value);
  }
};

// src/Feature/Suggest/SuggestFeature.ts
var SuggestFeature = class extends AbstractFeature {
  constructor(chooser, service) {
    super();
    this.replacer = null;
    this.resolver = service.createResolver(this.getId());
    this.createChooserReplacer(chooser);
  }
  isEnabled() {
    return this.state;
  }
  enable() {
    if (this.isEnabled()) {
      return;
    }
    this.replacer.enable();
    this.state = true;
  }
  disable() {
    this.replacer.disable();
    this.state = false;
  }
  getId() {
    return SuggestFeature.getId();
  }
  static getId() {
    return "suggest" /* Suggest */;
  }
  createChooserReplacer(chooser) {
    if (typeof chooser.prototype.setSuggestions !== "function") {
      return;
    }
    this.replacer = new FunctionReplacer(chooser.prototype, "setSuggestions", this, function(self2, args, vanilla) {
      if (Array.isArray(args == null ? void 0 : args[0])) {
        args[0] = self2.modifySuggestions(args[0]);
      }
      return vanilla.call(this, ...args);
    });
    this.replacer.enable();
  }
  modifySuggestions(items) {
    const aliases = /* @__PURE__ */ new Set();
    for (const item of items) {
      if (!(item == null ? void 0 : item.file)) {
        continue;
      }
      aliases.add(item.alias + item.file.path);
      if (!item || !item.type || item.type !== "file") {
        continue;
      }
      const alias = this.resolver.resolve(item.file.path);
      const value = alias + item.file.path;
      if (alias && !aliases.has(value)) {
        item.alias = alias;
        item.type = "alias";
        aliases.add(value);
      }
    }
    return items;
  }
};
SuggestFeature = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["newable:obsidian:chooser"])),
  __decorateParam(1, inject(inversify_types_default["feature:service"]))
], SuggestFeature);

// src/Feature/Starred/StarredManager.ts
var StarredManager = class extends AbstractManager {
  constructor(facade, logger) {
    super();
    this.facade = facade;
    this.logger = logger;
    this.enabled = false;
    this.view = null;
    this.ref = null;
  }
  async doUpdate(path) {
    return this.onChanged(path)[path] === true;
  }
  async doRefresh() {
    return this.onChanged();
  }
  initView() {
    var _a, _b;
    const view = (_b = (_a = this.facade.getViewsOfType("starred" /* ST */)) == null ? void 0 : _a[0]) != null ? _b : null;
    if (view === null) {
      this.logger.log("Could not find a view of starred type");
      return false;
    }
    this.view = view;
    return true;
  }
  subscribe() {
    var _a;
    const plugin = (_a = this.view.plugin) != null ? _a : null;
    if (plugin === null) {
      this.logger.log("Leaf does not have a plugin");
      return false;
    }
    this.ref = plugin.on("changed", () => {
      this.logger.log("Triggered by event");
      this.onChanged();
    });
    return true;
  }
  unsubscribe() {
    this.view.plugin.offref(this.ref);
    this.view.plugin.trigger("changed");
  }
  onChanged(path = null) {
    const listEl = this.view.listEl.findAll(".nav-file");
    const items = this.view.itemLookup;
    const result = {};
    for (const div of Array.from(listEl)) {
      const item = items.get(div);
      const content = div.find(".nav-file-title-content");
      result[item.path] = false;
      if (content && item.type === "file" && (!path || item.path === path)) {
        this.process(content, item.path, item.title).catch(console.error);
        result[item.path] = true;
      }
    }
    return result;
  }
  async process(div, path, original) {
    var _a;
    const title = (_a = this.resolver.resolve(path)) != null ? _a : original;
    if (div.getText() !== title) {
      div.setText(title);
    }
  }
  doEnable() {
    if (!this.isEnabled() && this.initView() && this.subscribe()) {
      this.enabled = true;
    }
  }
  doDisable() {
    if (this.isEnabled()) {
      this.unsubscribe();
      this.view = null;
      this.enabled = false;
    }
  }
  static getId() {
    return "starred" /* Starred */;
  }
  getId() {
    return StarredManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
StarredManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(1, inject(inversify_types_default.logger)),
  __decorateParam(1, named("manager:starred"))
], StarredManager);

// src/Feature/Graph/GraphManager.ts
var GraphManager = class extends AbstractManager {
  constructor(dispatcher, facade, factory, logger) {
    super();
    this.dispatcher = dispatcher;
    this.facade = facade;
    this.factory = factory;
    this.logger = logger;
    this.enabled = false;
    this.ref = null;
    this.replacement = null;
  }
  static getId() {
    return "graph" /* Graph */;
  }
  unbind() {
    if (this.ref) {
      this.logger.log("unbind");
      this.dispatcher.removeListener(this.ref);
      this.ref = null;
    }
  }
  bind() {
    this.logger.log("bind");
    this.ref = this.dispatcher.addListener({
      name: "layout:change",
      cb: () => {
        this.initReplacement() && this.unbind();
      }
    });
  }
  initReplacement() {
    const node = this.getFirstNode();
    if (node) {
      this.replacement = this.factory(
        Object.getPrototypeOf(node),
        "getDisplayText",
        this,
        function(self2, defaultArgs, vanilla) {
          const text = self2.resolver.resolve(this.id);
          return text != null ? text : vanilla.call(this, ...defaultArgs);
        }
      );
      this.replacement.enable();
      this.refresh().catch(console.error);
      return true;
    } else if (this.getViews().length) {
      this.runBackgroundInit();
      return true;
    }
    return false;
  }
  runBackgroundInit() {
    setTimeout(async () => {
      this.logger.log("init by backgroundInit");
      this.initReplacement();
    }, 200);
  }
  getFirstNode() {
    var _a, _b, _c;
    for (const view of this.getViews()) {
      const node = (_c = ((_b = (_a = view.renderer) == null ? void 0 : _a.nodes) != null ? _b : []).first()) != null ? _c : null;
      if (node) {
        return node;
      }
    }
    return null;
  }
  getViews() {
    return [...this.facade.getViewsOfType("graph" /* G */), ...this.facade.getViewsOfType("localgraph" /* LG */)];
  }
  doDisable() {
    var _a;
    this.unbind();
    (_a = this.replacement) == null ? void 0 : _a.disable();
    this.enabled = false;
  }
  doEnable() {
    if (!this.initReplacement()) {
      this.bind();
    }
    this.enabled = true;
  }
  doRefresh() {
    var _a;
    for (const view of this.getViews()) {
      (_a = view.renderer) == null ? void 0 : _a.onIframeLoad();
    }
    return Promise.resolve();
  }
  async doUpdate(path) {
    var _a, _b;
    let result = false;
    for (const view of this.getViews()) {
      for (const node of (_b = (_a = view.renderer) == null ? void 0 : _a.nodes) != null ? _b : []) {
        if (node.id === path) {
          result = true;
          view.renderer.onIframeLoad();
          break;
        }
      }
    }
    return result;
  }
  getId() {
    return GraphManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
GraphManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(1, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(2, inject(inversify_types_default["factory:replacer"])),
  __decorateParam(3, inject(inversify_types_default.logger)),
  __decorateParam(3, named("manager:graph"))
], GraphManager);

// src/Feature/MarkdownHeader/MarkdownHeaderManager.ts
var MarkdownHeaderManager = class extends AbstractManager {
  constructor(dispatcher, facade, logger) {
    super();
    this.dispatcher = dispatcher;
    this.facade = facade;
    this.logger = logger;
    this.ref = null;
    this.enabled = false;
  }
  static getId() {
    return "header" /* Header */;
  }
  doDisable() {
    this.dispatcher.removeListener(this.ref);
    this.facade.getViewsOfType("markdown" /* MD */).forEach(this.revert.bind(this));
    this.enabled = false;
  }
  doEnable() {
    this.ref = this.dispatcher.addListener({
      name: "layout:change",
      cb: () => this.refresh().catch(console.error)
    });
    this.enabled = true;
  }
  async doRefresh() {
    await this.innerUpdate();
    return Promise.resolve({});
  }
  async doUpdate(path) {
    return this.innerUpdate(path);
  }
  async innerUpdate(path = null) {
    const views = this.facade.getViewsOfType("markdown" /* MD */);
    let updated = false;
    for (const view of views) {
      if (!path || view.file.path === path) {
        const title = this.resolver.resolve(view.file.path);
        this.setTitle(view, title);
        updated = true;
      }
    }
    return updated;
  }
  setTitle(view, title) {
    this.logger.log(`Set title "${title != null ? title : " "}" for ${view.file.path}`);
    const container = view.titleContainerEl;
    if (!title) {
      return this.revert(view);
    }
    let el = this.findExistingFakeEl(container);
    if (title && el && el.innerText === title && !el.hidden) {
      return this.logger.log(`Set title "${title}" for ${view.file.path} is skipped`);
    }
    el = el != null ? el : this.createFakeEl(title, view);
    el.innerText = title;
    el.hidden = false;
    view.titleEl.hidden = true;
  }
  revert(view) {
    const container = view.titleContainerEl;
    const el = this.findExistingFakeEl(container);
    if (el) {
      container.removeChild(el);
    }
    view.titleEl.hidden = false;
    return;
  }
  findExistingFakeEl(container) {
    for (const i of Array.from(container.children)) {
      if (i.hasAttribute("data-ofmt") && i instanceof HTMLDivElement) {
        return i;
      }
    }
    return null;
  }
  createFakeEl(title, view) {
    const el = document.createElement("div");
    el.className = "view-header-title";
    el.dataset["ofmt"] = "true";
    el.innerText = title;
    el.hidden = true;
    el.onclick = () => {
      el.hidden = true;
      view.titleEl.hidden = false;
      view.titleEl.focus();
      view.titleEl.onblur = () => {
        view.titleEl.hidden = true;
        el.hidden = false;
      };
    };
    view.titleContainerEl.appendChild(el);
    return el;
  }
  getId() {
    return MarkdownHeaderManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
MarkdownHeaderManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(1, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(2, inject(inversify_types_default.logger)),
  __decorateParam(2, named(`manager:${MarkdownHeaderManager.getId()}`))
], MarkdownHeaderManager);

// src/Feature/Alias/Validator.ts
var ValidatorRequired = class {
  validate(metadata) {
    return metadata.frontmatter ? true : false;
  }
};
ValidatorRequired = __decorateClass([
  injectable()
], ValidatorRequired);
var ValidatorAuto = class {
  validate(metadata) {
    if (!metadata.frontmatter) {
      metadata.frontmatter = {
        position: {
          end: {
            col: 0,
            line: 0,
            offset: 0
          },
          start: {
            col: 0,
            line: 0,
            offset: 0
          }
        }
      };
    }
    return true;
  }
};
ValidatorAuto = __decorateClass([
  injectable()
], ValidatorAuto);

// src/Feature/InlineTitle/InlineTitleManager.ts
var InlineTitleManager = class extends AbstractManager {
  constructor(dispatcher, facade, logger, fakeTitleElementService) {
    super();
    this.dispatcher = dispatcher;
    this.facade = facade;
    this.logger = logger;
    this.fakeTitleElementService = fakeTitleElementService;
    this.ref = null;
    this.enabled = false;
  }
  static getId() {
    return "inlineTitle" /* InlineTitle */;
  }
  doDisable() {
    this.dispatcher.removeListener(this.ref);
    this.fakeTitleElementService.removeAll();
    this.enabled = false;
  }
  doEnable() {
    this.ref = this.dispatcher.addListener({
      name: "layout:change",
      cb: () => this.refresh().catch(console.error)
    });
    this.enabled = true;
  }
  async doRefresh() {
    await this.innerUpdate();
    return Promise.resolve({});
  }
  async doUpdate(path) {
    return this.innerUpdate(path);
  }
  async resolve(path) {
    return this.resolver.resolve(path);
  }
  async innerUpdate(path = null) {
    const views = this.facade.getViewsOfType("markdown" /* MD */);
    const promises = [];
    const ids = [];
    for (const view of views) {
      if (!path || view.file.path === path) {
        promises.push(
          this.resolve(view.file.path).then(
            (title) => title ? ids.push(this.setTitle(view, title)) : this.resetTitle(this.getTitleElId(view))
          ).catch(console.error)
        );
      }
    }
    await Promise.all(promises);
    this.fakeTitleElementService.removeExcept(ids);
    return promises.length > 0;
  }
  resetTitle(id3) {
    this.fakeTitleElementService.remove(id3);
  }
  setTitle(view, title) {
    this.logger.log(`Set inline title "${title != null ? title : " "}" for ${view.file.path}`);
    const id3 = this.getTitleElId(view);
    const original = view.inlineTitleEl;
    const { created } = this.fakeTitleElementService.getOrCreate({ original, title, id: id3, events: ["click"] });
    if (created) {
      this.fakeTitleElementService.setVisible(id3, true);
    }
    return id3;
  }
  getTitleElId(view) {
    return `${view.getState().mode}-${this.getId()}-${view.leaf.id}`;
  }
  getId() {
    return InlineTitleManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
InlineTitleManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(1, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(2, inject(inversify_types_default.logger)),
  __decorateParam(2, named(`manager:${InlineTitleManager.getId()}`)),
  __decorateParam(3, inject(inversify_types_default["service:fake_title_element"]))
], InlineTitleManager);

// src/Feature/Canvas/CanvasManager.ts
var import_obsidian4 = require("obsidian");
var CanvasManager = class extends AbstractManager {
  constructor(dispatcher, facade, logger, fakeTitleElementService) {
    super();
    this.dispatcher = dispatcher;
    this.facade = facade;
    this.logger = logger;
    this.fakeTitleElementService = fakeTitleElementService;
    this.ref = null;
    this.enabled = false;
    this.queue = /* @__PURE__ */ new Set();
    this.updateByRequestFrame = (0, import_obsidian4.debounce)(
      () => {
        this.logger.log(`updateByRequestFrame`, this.queue);
        Array.from(this.queue.values()).forEach((e) => this.innerUpdate(e) && this.queue.delete(e));
      },
      1e3,
      true
    );
  }
  static getId() {
    return "canvas" /* Canvas */;
  }
  doDisable() {
    this.dispatcher.removeListener(this.ref);
    this.fakeTitleElementService.removeAll();
    this.enabled = false;
  }
  doEnable() {
    this.ref = this.dispatcher.addListener({
      name: "layout:change",
      cb: () => this.refresh().catch(console.error)
    });
    this.enabled = true;
  }
  async doRefresh() {
    await this.innerUpdate();
    return Promise.resolve({});
  }
  async doUpdate(path) {
    return this.innerUpdate(path);
  }
  async resolve(path) {
    return this.resolver.resolve(path);
  }
  async innerUpdate(path = null) {
    const promises = [];
    this.logger.log(`inner update "${path}"`);
    const canvasViews = this.facade.getViewsOfType("canvas" /* CV */);
    for (const view of canvasViews) {
      if (!view.file) {
        continue;
      }
      const currentPath = view.file.path;
      const canvas = view.canvas;
      for (const node of canvas.nodes.values()) {
        if (!node.filePath || path && path !== node.filePath && path !== currentPath) {
          continue;
        }
        promises.push(
          this.resolve(node.filePath).then((title) => {
            if (title) {
              this.setNodeTitle(node, title);
            } else {
              this.restoreNodeTitle(node);
            }
          })
        );
      }
      if (!canvas.requestFrame._originalFunc) {
        const originalFunc = canvas.requestFrame;
        const manager = this;
        canvas.requestFrame = function(...args) {
          canvas.requestFrame._originalFunc.apply(this, args);
          if (manager.enabled) {
            manager.queue.add(currentPath);
            manager.updateByRequestFrame();
          } else {
            canvas.requestFrame = canvas.requestFrame._originalFunc;
          }
        };
        canvas.requestFrame._originalFunc = originalFunc;
      }
    }
    await Promise.all(promises);
    return promises.length > 0;
  }
  restoreNodeTitle(node) {
    const ids = this.makeFakeElementIds(node.canvas.view.file.path, node.filePath);
    this.fakeTitleElementService.remove(ids.label);
    this.fakeTitleElementService.remove(ids.inline);
  }
  async setNodeTitle(node, title) {
    var _a;
    do {
      await new Promise((resolve2) => setTimeout(resolve2, 200));
    } while (!node.initialized);
    const view = node.canvas.view;
    this.logger.log(`Set canvas title "${title}" for canvas "${view.file.path}" and node "${node.filePath}"`);
    const ids = this.makeFakeElementIds(view.file.path, node.filePath);
    const label = this.fakeTitleElementService.getOrCreate({
      original: node.labelEl,
      title,
      id: ids.label,
      events: ["hover"]
    });
    if (label == null ? void 0 : label.created) {
      this.fakeTitleElementService.setVisible(ids.label, true);
    }
    const inlineTitleEl = (_a = node.contentEl) == null ? void 0 : _a.querySelector(".inline-title");
    const inline = this.fakeTitleElementService.getOrCreate({
      original: inlineTitleEl,
      title,
      id: ids.inline,
      events: ["click"]
    });
    if (inline == null ? void 0 : inline.created) {
      this.fakeTitleElementService.setVisible(ids.inline, true);
    }
    if (node.placeholderEl.getText() !== title) {
      node.placeholderEl.setText(title);
    }
  }
  makeFakeElementIds(canvasPath, nodePath) {
    const prefix = `${canvasPath}-${nodePath}`;
    return {
      label: `${prefix}-label`,
      inline: `${prefix}-inline`
    };
  }
  getId() {
    return CanvasManager.getId();
  }
  isEnabled() {
    return this.enabled;
  }
};
CanvasManager = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(1, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(2, inject(inversify_types_default.logger)),
  __decorateParam(2, named(`manager:${CanvasManager.getId()}`)),
  __decorateParam(3, inject(inversify_types_default["service:fake_title_element"]))
], CanvasManager);

// src/Utils/FeatureHelper.ts
var FeatureHelper = class {
  getOrderedFeatures() {
    return [
      "alias" /* Alias */,
      "explorer" /* Explorer */,
      "explorer:sort" /* ExplorerSort */,
      "graph" /* Graph */,
      "header" /* Header */,
      "starred" /* Starred */,
      "search" /* Search */,
      "suggest" /* Suggest */,
      "tab" /* Tab */,
      "inlineTitle" /* InlineTitle */,
      "canvas" /* Canvas */,
      "backlink" /* Backlink */,
      "noteLink" /* NoteLink */
    ];
  }
  getName(feature) {
    switch (feature) {
      case "alias" /* Alias */:
        return t2("feature.alias.name");
      case "explorer" /* Explorer */:
        return t2("feature.explorer.name");
      case "explorer:sort" /* ExplorerSort */:
        return t2("feature.explorer:sort.name");
      case "graph" /* Graph */:
        return t2("feature.graph.name");
      case "header" /* Header */:
        return t2("feature.header.name");
      case "starred" /* Starred */:
        return t2("feature.starred.name");
      case "search" /* Search */:
        return t2("feature.search.name");
      case "suggest" /* Suggest */:
        return t2("feature.suggest.name");
      case "tab" /* Tab */:
        return t2("feature.tab.name");
      case "inlineTitle" /* InlineTitle */:
        return t2("feature.inlineTitle.name");
      case "canvas" /* Canvas */:
        return t2("feature.canvas.name");
      case "backlink" /* Backlink */:
        return t2("feature.backlink.name");
      case "noteLink" /* NoteLink */:
        return t2("feature.noteLink.name");
    }
  }
  getDescription(feature) {
    switch (feature) {
      case "alias" /* Alias */:
        return t2("feature.alias.desc");
      case "explorer" /* Explorer */:
        return t2("feature.explorer.desc");
      case "explorer:sort" /* ExplorerSort */:
        return t2("feature.explorer:sort.desc");
      case "graph" /* Graph */:
        return t2("feature.graph.desc");
      case "header" /* Header */:
        return t2("feature.header.desc");
      case "starred" /* Starred */:
        return t2("feature.starred.desc");
      case "search" /* Search */:
        return t2("feature.search.desc");
      case "suggest" /* Suggest */:
        return t2("feature.suggest.desc");
      case "tab" /* Tab */:
        return t2("feature.tab.desc");
      case "inlineTitle" /* InlineTitle */:
        return t2("feature.inlineTitle.desc");
      case "canvas" /* Canvas */:
        return t2("feature.canvas.desc");
      case "backlink" /* Backlink */:
        return t2("feature.backlink.desc");
      case "noteLink" /* NoteLink */:
        return t2("feature.noteLink.desc");
    }
  }
  getDocSection(feature) {
    switch (feature) {
      case "noteLink" /* NoteLink */:
        return "Features/NoteLink.md";
      default:
        return feature;
    }
  }
};
FeatureHelper = __decorateClass([
  injectable()
], FeatureHelper);

// src/Feature/FeatureService.ts
var FeatureService = class {
  constructor(service) {
    this.service = service;
  }
  createResolver(name) {
    const main = this.service.createNamed(`${name}:main`);
    const fallback = this.service.createNamed(`${name}:fallback`);
    return {
      resolve(path) {
        var _a;
        return (_a = main.resolve(path)) != null ? _a : fallback.resolve(path);
      }
    };
  }
};
FeatureService = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["resolver:service"]))
], FeatureService);

// src/Feature/Backlink/BacklinkFeature.ts
var BacklinkFeature = class extends AbstractFeature {
  constructor(facade, logger, dispatcher, service, mutateService) {
    super();
    this.facade = facade;
    this.logger = logger;
    this.dispatcher = dispatcher;
    this.mutateService = mutateService;
    this.enabled = false;
    this.refs = [];
    this.dProcess = null;
    this.timer = null;
    this.isBacklinkWrapped = false;
    this.resolver = service.createResolver(this.getId());
    this.dProcess = () => {
      if (this.timer) {
        clearTimeout(this.timer);
      }
      this.timer = setTimeout(this.process.bind(this), 50);
    };
  }
  isEnabled() {
    return this.enabled;
  }
  enable() {
    this.enabled = this.facade.isInternalPluginEnabled(this.getId());
    this.logger.log(`Manager state is ${this.enabled}`);
    if (!this.enabled) {
      return;
    }
    this.refs = [
      this.dispatcher.addListener({
        name: "metadata:cache:changed",
        cb: this.dProcess.bind(this)
      }),
      this.dispatcher.addListener({
        name: "layout:change",
        cb: this.dProcess.bind(this)
      })
    ];
    this.process();
  }
  disable() {
    this.enabled = false;
    if (this.refs.length) {
      this.refs.forEach((e) => this.dispatcher.removeListener(e));
      this.refs = [];
      this.mutateService.destroyByTag(this.getId());
    }
  }
  process() {
    var _a;
    this.logger.log("process");
    this.processBacklinkLayout();
    for (const view of this.facade.getViewsOfType("markdown" /* MD */)) {
      const dom = (_a = view == null ? void 0 : view.backlinks) == null ? void 0 : _a.backlinkDom;
      if (dom) {
        this.mutateService.wrapDom(dom, this.resolver, this.getId());
      }
    }
  }
  processBacklinkLayout() {
    var _a, _b;
    if (this.isBacklinkWrapped) {
      return;
    }
    const view = (_a = this.facade.getViewsOfType("backlink" /* BL */)[0]) != null ? _a : null;
    if ((_b = view == null ? void 0 : view.backlink) == null ? void 0 : _b.backlinkDom) {
      this.mutateService.wrapDom(view.backlink.backlinkDom, this.resolver, this.getId());
    }
    this.isBacklinkWrapped = true;
  }
  getId() {
    return BacklinkFeature.getId();
  }
  static getId() {
    return "backlink" /* Backlink */;
  }
};
BacklinkFeature = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(1, inject(inversify_types_default.logger)),
  __decorateParam(1, named("backlink")),
  __decorateParam(2, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(3, inject(inversify_types_default["feature:service"])),
  __decorateParam(4, inject(inversify_types_default["service:search:dom:wrapper"]))
], BacklinkFeature);

// src/Feature/NoteLink/NoteLinkFeature.ts
var import_obsidian5 = require("obsidian");
var NoteLinkFeature = class extends AbstractFeature {
  constructor(featureService, service, dispatcher, approve, facade, config) {
    super();
    this.service = service;
    this.dispatcher = dispatcher;
    this.approve = approve;
    this.facade = facade;
    this.config = config;
    this.enabled = false;
    this.refs = [];
    this.resolver = featureService.createResolver(this.getId());
  }
  disable() {
    this.refs.forEach((e) => this.dispatcher.removeListener(e));
    this.refs = [];
    this.enabled = false;
  }
  enable() {
    this.refs.push(
      this.dispatcher.addListener({
        name: "metadata:cache:changed",
        cb: (e) => this.requestApprove(e.get().path)
      })
    );
    this.enabled = true;
  }
  shouldChangeLink(link, destTitle) {
    if (!destTitle || destTitle === link.alias) {
      return false;
    }
    const hasAlias = /.+\|.+/.test(link.original);
    return this.config.strategy === "all" /* All */ || !hasAlias;
  }
  async requestApprove(path) {
    const links = this.service.getNoteLinks(path);
    const changes = [];
    for (const link of links) {
      const title = this.resolver.resolve(link.dest);
      if (this.shouldChangeLink(link, title)) {
        changes.push({
          original: link.original,
          replace: `[[${link.link}|${title}]]`
        });
      }
    }
    if (changes.length === 0) {
      return;
    }
    const exec = this.config.approval ? await this.approve.request(path, changes) : true;
    if (exec) {
      await this.executeChanges(path, changes);
    }
  }
  async executeChanges(path, changes) {
    const file = this.facade.getTFile(path);
    let content = file instanceof import_obsidian5.TFile ? await this.facade.getFileContent(file) : null;
    if (!content) {
      return;
    }
    for (const { original, replace } of changes) {
      content = content.replace(original, replace);
    }
    await this.facade.modifyFile(file, content).catch(console.error);
  }
  getId() {
    return NoteLinkFeature.getId();
  }
  isEnabled() {
    return this.enabled;
  }
  static getId() {
    return "noteLink" /* NoteLink */;
  }
};
NoteLinkFeature = __decorateClass([
  __decorateParam(0, inject(inversify_types_default["feature:service"])),
  __decorateParam(1, inject(inversify_types_default["service:note:link"])),
  __decorateParam(2, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(3, inject(inversify_types_default["feature:notelink:approve"])),
  __decorateParam(4, inject(inversify_types_default["facade:obsidian"])),
  __decorateParam(5, inject(inversify_types_default["feature:config"])),
  __decorateParam(5, named("noteLink" /* NoteLink */))
], NoteLinkFeature);

// src/Feature/NoteLink/NoteLinkApprove.ts
var NoteLinkApprove = class {
  constructor(factory) {
    this.factory = factory;
  }
  async request(path, changes) {
    return new Promise((r) => {
      const modal = this.factory();
      let approved = false;
      modal.onClose = () => r(approved);
      const { contentEl } = modal;
      contentEl.setText(`Approve changes for ${path}`);
      contentEl.createEl(
        "ul",
        null,
        (ul) => changes.forEach((e) => ul.createEl("li", { text: `${e.original} => ${e.replace}` }))
      );
      const btnContainer = contentEl.createDiv("modal-button-container");
      btnContainer.createEl("button", { cls: "mod-cta", text: t2("apply") }).addEventListener("click", () => {
        approved = true;
        modal.close();
      });
      btnContainer.createEl("button", { text: t2("cancel") }).addEventListener("click", () => modal.close());
      modal.open();
    });
  }
};
NoteLinkApprove = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:obsidian:modal"]))
], NoteLinkApprove);

// src/Feature/Alias/AliasConfig.ts
var AliasConfig = class {
  constructor(storage) {
    this.storage = storage;
  }
  get config() {
    return this.storage.get("features").get("alias" /* Alias */);
  }
  getStrategy() {
    return this.config.get("strategy").value();
  }
  getValidator() {
    return this.config.get("validator").value();
  }
};
AliasConfig = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["settings:storage"]))
], AliasConfig);

// config/services/feature.config.ts
var feature_config_default = (container) => {
  container.bind(inversify_types_default["feature:service"]).to(FeatureService).inSingletonScope();
  container.bind(inversify_types_default["feature:composer"]).to(FeatureComposer).inSingletonScope();
  container.bind(inversify_types_default["manager:composer"]).to(ManagerComposer).inSingletonScope();
  container.bind(inversify_types_default["feature:helper"]).to(FeatureHelper).inSingletonScope();
  container.bind(inversify_types_default["factory:feature"]).toAutoNamedFactory(inversify_types_default.feature).onActivation((c, i) => (name) => {
    const feature = i(name);
    if (feature instanceof AbstractManager) {
      const service = c.container.get(inversify_types_default["feature:service"]);
      feature.setResolver(service.createResolver(feature.getId()));
    }
    return feature;
  });
  container.bind(inversify_types_default.feature).to(AliasFeature).whenTargetNamed(AliasFeature.getId());
  container.bind(inversify_types_default.feature).to(ExplorerManager).whenTargetNamed(ExplorerManager.getId());
  container.bind(inversify_types_default.feature).to(ExplorerSort).whenTargetNamed(ExplorerSort.getId());
  container.bind(inversify_types_default.feature).to(SearchManager).whenTargetNamed(SearchManager.getId());
  container.bind(inversify_types_default.feature).to(StarredManager).whenTargetNamed(StarredManager.getId());
  container.bind(inversify_types_default.feature).to(TabManager).whenTargetNamed(TabManager.getId());
  container.bind(inversify_types_default.feature).to(SuggestFeature).whenTargetNamed(SuggestFeature.getId());
  container.bind(inversify_types_default.feature).to(GraphManager).whenTargetNamed(GraphManager.getId());
  container.bind(inversify_types_default.feature).to(MarkdownHeaderManager).whenTargetNamed(MarkdownHeaderManager.getId());
  container.bind(inversify_types_default.feature).to(BacklinkFeature).whenTargetNamed(BacklinkFeature.getId());
  container.bind(inversify_types_default.feature).to(NoteLinkFeature).whenTargetNamed(NoteLinkFeature.getId());
  container.bind(inversify_types_default.feature).to(InlineTitleManager).whenTargetNamed(InlineTitleManager.getId());
  container.bind(inversify_types_default.feature).to(CanvasManager).whenTargetNamed(CanvasManager.getId());
  container.bind(inversify_types_default["factory:alias:modifier:strategy"]).toAutoNamedFactory(inversify_types_default["alias:modifier:strategy"]);
  container.bind(inversify_types_default["alias:modifier:strategy"]).to(EnsureStrategy).whenTargetNamed("ensure" /* Ensure */);
  container.bind(inversify_types_default["alias:modifier:strategy"]).to(AdjustStrategy).whenTargetNamed("adjust" /* Adjust */);
  container.bind(inversify_types_default["alias:modifier:strategy"]).to(ReplaceStrategy).whenTargetNamed("replace" /* Replace */);
  container.bind(inversify_types_default["feature:alias:config"]).to(AliasConfig);
  container.bind(inversify_types_default["factory:alias:modifier:validator"]).toAutoNamedFactory(inversify_types_default["alias:modifier:validator"]);
  container.bind(inversify_types_default["alias:modifier:validator"]).to(ValidatorAuto).whenTargetNamed("fa" /* FrontmatterAuto */);
  container.bind(inversify_types_default["alias:modifier:validator"]).to(ValidatorRequired).whenTargetNamed("fr" /* FrontmatterRequired */);
  container.bind(inversify_types_default["feature:notelink:approve"]).to(NoteLinkApprove);
  container.bind(inversify_types_default["feature:config"]).toDynamicValue((c) => {
    const feature = c.currentRequest.target.getNamedTag().value;
    return c.container.get(inversify_types_default["settings:storage"]).get("features").get(feature).value();
  }).when(() => true);
};

// src/Settings/FeatureBuilder/DefaultBuilder.ts
var import_obsidian6 = require("obsidian");

// src/Settings/FeatureBuilder/AbstractBuilder.ts
var AbstractBuilder = class {
  setContext(context) {
    this.context = context;
  }
};

// src/Settings/FeatureBuilder/DefaultBuilder.ts
var DefaultBuilder = class extends AbstractBuilder {
  build({ id: id3, name, desc, settings }) {
    new import_obsidian6.Setting(this.context.getContainer()).setName(name).setDesc(desc).addToggle(
      (e) => e.setValue(settings.enabled).onChange((v) => {
        this.context.getDispatcher().dispatch("settings:tab:feature:changed", new Event({ id: id3, value: { enabled: v } }));
      })
    );
  }
};

// src/Settings/FeatureBuilder/AliasBuilder.ts
var import_obsidian7 = require("obsidian");
var AliasBuilder = class extends AbstractBuilder {
  build({ id: id3, name, desc, settings }) {
    this.id = id3;
    this.desc = desc;
    this.setting = new import_obsidian7.Setting(this.context.getContainer()).setName(name).setDesc(desc);
    this.buildValidatorDropdown(settings.validator);
    this.buildStrategyDropdown(settings.strategy);
    this.buildToggle(settings.enabled);
    this.actualizeDesc();
  }
  buildValidatorDropdown(value) {
    this.validatorDropdown = new import_obsidian7.DropdownComponent(this.setting.controlEl).addOptions({
      ["fa" /* FrontmatterAuto */]: t2("feature.alias.validator.auto.name"),
      ["fr" /* FrontmatterRequired */]: t2("feature.alias.validator.required.name")
    }).setValue(value ? value : "fr" /* FrontmatterRequired */).onChange(this.onChange.bind(this));
  }
  buildStrategyDropdown(value) {
    this.strategyDropdown = new import_obsidian7.DropdownComponent(this.setting.controlEl).addOptions({
      ["ensure" /* Ensure */]: t2("feature.alias.strategy.ensure.name"),
      ["adjust" /* Adjust */]: t2("feature.alias.strategy.adjust.name"),
      ["replace" /* Replace */]: t2("feature.alias.strategy.replace.name")
    }).setValue(value ? value : "ensure" /* Ensure */).onChange(this.onChange.bind(this));
  }
  buildToggle(value) {
    this.setting.addToggle((e) => this.toggle = e.setValue(value).onChange(this.onChange.bind(this)));
  }
  onChange() {
    this.context.getDispatcher().dispatch(
      "settings:tab:feature:changed",
      new Event({
        id: this.id,
        value: {
          enabled: this.toggle.getValue(),
          strategy: this.strategyDropdown.getValue(),
          validator: this.validatorDropdown.getValue()
        }
      })
    );
    this.actualizeDesc();
  }
  getStrategyFragment() {
    let text = "";
    switch (this.strategyDropdown.getValue()) {
      case "ensure" /* Ensure */:
        text = t2("feature.alias.strategy.ensure.desc");
        break;
      case "replace" /* Replace */:
        text = t2("feature.alias.strategy.replace.desc");
        break;
      case "adjust" /* Adjust */:
        text = t2("feature.alias.strategy.adjust.desc");
        break;
    }
    const fragment = createFragment();
    fragment.createEl("b", "", (e) => e.setText(`${t2("strategy")}: `));
    fragment.appendText(text);
    return fragment;
  }
  getValidatorFragment() {
    let text = "";
    switch (this.validatorDropdown.getValue()) {
      case "fa" /* FrontmatterAuto */: {
        text = t2("feature.alias.validator.auto.desc");
        break;
      }
      case "fr" /* FrontmatterRequired */: {
        text = t2("feature.alias.validator.required.desc");
        break;
      }
    }
    const fragment = createFragment();
    fragment.createEl("b", "", (e) => e.setText(`${t2("validator")}: `));
    fragment.appendText(text);
    return fragment;
  }
  actualizeDesc() {
    const fragment = createFragment();
    fragment.appendText(this.desc);
    fragment.createEl("br");
    fragment.append(this.getValidatorFragment());
    fragment.createEl("br");
    fragment.append(this.getStrategyFragment());
    this.setting.setDesc(fragment);
  }
};

// src/Settings/FeatureBuilder/ExplorerSortBuilder.ts
var import_obsidian8 = require("obsidian");
var ExplorerSortBuilder = class extends AbstractBuilder {
  constructor() {
    super();
    this.toggle = null;
    this.setting = null;
    this.ref = null;
  }
  build(options) {
    this.bind();
    this.setting = new import_obsidian8.Setting(this.context.getContainer()).setName(options.name).setDesc(options.desc);
    this.setting.addToggle((c) => this.toggle = c);
    this.toggle.setValue(options.settings.enabled).onChange(
      (v) => this.context.getDispatcher().dispatch(
        "settings:tab:feature:changed",
        new Event({
          id: options.id,
          value: { enabled: v }
        })
      )
    );
    if (!this.context.getSettings().explorer.enabled) {
      this.setting.settingEl.hide();
    }
  }
  bind() {
    this.ref = this.context.getDispatcher().addListener({
      name: "settings:tab:feature:changed",
      cb: (e) => {
        if (e.get().id === "explorer" /* Explorer */) {
          this.toggle.setValue(false);
          if (e.get().value.enabled) {
            this.setting.settingEl.show();
          } else {
            this.setting.settingEl.hide();
          }
        }
      }
    });
    this.context.getDispatcher().addListener({
      name: "settings:tab:close",
      once: true,
      cb: () => {
        this.context.getDispatcher().removeListener(this.ref);
        this.ref = null;
      }
    });
  }
};

// src/Settings/SettingBuilders/AbstractBuilder.ts
var AbstractBuilder2 = class {
  constructor() {
    this.item = null;
    this.container = null;
    this.name = null;
  }
  build({ name, container, item }) {
    this.name = name;
    this.item = item;
    this.container = container;
    this.doBuild();
  }
};
AbstractBuilder2 = __decorateClass([
  injectable()
], AbstractBuilder2);

// src/Settings/SettingBuilders/Templates/TemplatesBuilder.ts
var import_obsidian9 = require("obsidian");
var TemplatesBuilder = class extends AbstractBuilder2 {
  constructor(factory, helper) {
    super();
    this.factory = factory;
    this.helper = helper;
  }
  support(k) {
    return k === "templates";
  }
  doBuild() {
    this.buildTemplate();
    this.buildFallbackTemplate();
    this.buildConfigButton();
  }
  createDocFragment(text, section = null) {
    return createFragment(
      (e) => e.createEl("a", {
        href: GITHUB_DOCS + "Templates.md" + (section ? `#${section}` : ""),
        text
      })
    );
  }
  buildTemplate() {
    new import_obsidian9.Setting(this.container).setName(this.createDocFragment(t2("template.commmon.main.name"))).setDesc(t2("template.commmon.main.desc")).addText(
      (text) => {
        var _a;
        return text.setPlaceholder(t2("template.placeholder")).setValue((_a = this.item.get("common").get("main").value()) != null ? _a : "").onChange(async (value) => this.item.get("common").get("main").set(value));
      }
    );
  }
  buildFallbackTemplate() {
    new import_obsidian9.Setting(this.container).setName(this.createDocFragment(t2("template.commmon.fallback.name"))).setDesc(t2("template.commmon.fallback.desc")).addText(
      (text) => {
        var _a;
        return text.setPlaceholder(t2("template.placeholder")).setValue((_a = this.item.get("common").get("fallback").value()) != null ? _a : "").onChange(async (value) => this.item.get("common").get("fallback").set(value));
      }
    );
  }
  buildConfigButton() {
    const getDesc = (type, value) => value ? t2("template.specific") : t2("template.used", { value: this.item.get("common").get(type).value() });
    new import_obsidian9.Setting(this.container).setName(this.createDocFragment(t2("template.features.name"), "features-templates")).setDesc(t2("template.features.desc")).addButton(
      (cb) => cb.setButtonText(t2("manage")).onClick(() => {
        const modal = this.factory();
        const { contentEl } = modal;
        contentEl.setText(t2("template.features.name"));
        for (const feature of Object.values(Feature)) {
          if (feature === "explorer:sort" /* ExplorerSort */) {
            continue;
          }
          if (!this.item.get(feature)) {
            this.item.add(feature, { main: null, fallback: null });
          }
          const templates = this.item.get(feature);
          contentEl.createEl("h4", null, (e) => e.setText(this.helper.getName(feature)));
          for (const type of Object.keys(templates.value())) {
            const s = new import_obsidian9.Setting(contentEl).setName(t2(`template.${type}`)).setDesc(getDesc(type, templates.get(type).value())).addText(
              (text) => text.setPlaceholder(this.item.get("common").get(type).value()).setValue(templates.get(type).value()).onChange((value) => {
                templates.get(type).set(value ? value : null);
                s.setDesc(getDesc(type, value));
              })
            );
          }
        }
        modal.open();
      })
    );
  }
};
TemplatesBuilder = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:obsidian:modal"])),
  __decorateParam(1, inject(inversify_types_default["feature:helper"]))
], TemplatesBuilder);

// src/Settings/SettingBuilders/Rules/RulesBuilder.ts
var RulesBuiler = class extends AbstractBuilder2 {
  constructor(factory) {
    super();
    this.factory = factory;
  }
  doBuild() {
    this.container.createEl("h4", { text: t2("rule.name") });
    const builders = this.factory("rules");
    for (const key of this.orderedKeys) {
      for (const builder of builders) {
        builder.support(key) && builder.build({
          name: key,
          container: this.container,
          item: this.item.get(key)
        });
      }
    }
  }
  get orderedKeys() {
    return ["paths", "delimiter"];
  }
  support(k) {
    return k === "rules";
  }
};
RulesBuiler = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:settings:builder"]))
], RulesBuiler);

// src/Settings/SettingBuilders/Features/FeaturesBuilder.ts
var FeaturesBuilder = class extends AbstractBuilder2 {
  constructor(builderFactory, dispatcher, helper) {
    super();
    this.builderFactory = builderFactory;
    this.dispatcher = dispatcher;
    this.helper = helper;
    this.ref = null;
  }
  support(k) {
    return k === "features";
  }
  bind() {
    this.ref = this.dispatcher.addListener({
      name: "settings:tab:feature:changed",
      cb: (e) => this.item.get(e.get().id).set(e.get().value)
    });
    this.dispatcher.addListener({
      name: "settings:tab:close",
      cb: () => this.dispatcher.removeListener(this.ref),
      once: true
    });
  }
  doBuild() {
    var _a;
    this.bind();
    this.container.createEl("h4", { text: t2("features") });
    const data = this.helper.getOrderedFeatures().map((feature) => ({
      desc: this.helper.getDescription(feature),
      feature,
      name: this.helper.getName(feature),
      doc: {
        link: `${GITHUB_DOCS}/${this.helper.getDocSection(feature)}`
      }
    }));
    for (const item of data) {
      const builder = (_a = this.builderFactory(item.feature)) != null ? _a : this.builderFactory("default");
      const settings = this.item.get(item.feature).value();
      builder.setContext({
        getContainer: () => this.container,
        getSettings: () => this.item.value(),
        getDispatcher: () => this.dispatcher
      });
      builder.build({ id: item.feature, desc: item.desc, name: item.name, settings, doc: item.doc });
    }
  }
};
FeaturesBuilder = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:settings:feature:builder"])),
  __decorateParam(1, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(2, inject(inversify_types_default["feature:helper"]))
], FeaturesBuilder);

// src/Settings/SettingBuilders/Util/UtilBuilder.ts
var import_obsidian10 = require("obsidian");
var UtilBuilder = class {
  constructor() {
    this.isTitleBuild = false;
  }
  build({ name, item, container }) {
    this.buildTitle(container);
    switch (name) {
      case "boot": {
        this.buildBoot(item, container);
        break;
      }
      case "debug": {
        this.buildDebug(item, container);
        break;
      }
    }
  }
  buildTitle(container) {
    if (!this.isTitleBuild) {
      container.createEl("h4", { text: t2("util") });
      this.isTitleBuild = true;
    }
  }
  buildDebug(item, container) {
    new import_obsidian10.Setting(container).setName(t2("debug_info.title")).setDesc(t2("debug_info.desc")).addToggle((e) => e.setValue(item.value()).onChange((e2) => item.set(e2)));
  }
  buildBoot(item, container) {
    new import_obsidian10.Setting(container).setName(t2("boot_delay.title")).setDesc(t2("boot_delay.desc")).addText(
      (e) => e.setValue(item.get("delay").value().toString()).onChange((s) => {
        const v = !isNaN(parseInt(s)) ? parseInt(s) : 0;
        e.setValue(v.toString());
        item.get("delay").set(v);
      })
    );
  }
  support(k) {
    return ["boot", "debug"].includes(k);
  }
};
UtilBuilder = __decorateClass([
  injectable()
], UtilBuilder);

// src/Settings/SettingBuilders/Rules/RulesDelimiterBuilder.ts
var import_obsidian11 = require("obsidian");
var RulesDelimiterBuilder = class extends AbstractBuilder2 {
  constructor() {
    super(...arguments);
    this.setting = null;
    this.text = null;
  }
  support(k) {
    return k === "delimiter";
  }
  doBuild() {
    this.setting = new import_obsidian11.Setting(this.container).setName(t2("rule.delimiter.name")).setDesc(t2("rule.delimiter.desc"));
    this.buildDropdown();
    this.buildText();
  }
  buildDropdown() {
    const enabled = this.item.get("enabled");
    new import_obsidian11.DropdownComponent(this.setting.controlEl).addOptions({ N: t2("rule.delimiter.first"), Y: t2("rule.delimiter.join") }).setValue(enabled.value() ? "Y" : "N").onChange((e) => {
      enabled.set(e === "Y");
      this.text.setValue("").setPlaceholder(this.getPlaceholder()).setDisabled(e === "N").onChanged();
    });
  }
  buildText() {
    const v = this.item.get("value");
    this.text = new import_obsidian11.TextComponent(this.setting.controlEl).setValue(v.value()).setDisabled(!this.isEnabled()).setPlaceholder(this.getPlaceholder()).onChange((e) => v.set(e));
  }
  getPlaceholder() {
    return this.isEnabled() ? t2("rule.delimiter.placeholder.join") : t2("rule.delimiter.placeholder.first");
  }
  isEnabled() {
    return this.item.get("enabled").value();
  }
};
RulesDelimiterBuilder = __decorateClass([
  injectable()
], RulesDelimiterBuilder);

// src/Settings/SettingBuilders/Rules/RulesPathsBuilder.ts
var import_obsidian12 = require("obsidian");
var RulesPathsBuilder = class extends AbstractBuilder2 {
  constructor() {
    super(...arguments);
    this.settings = null;
  }
  doBuild() {
    this.settings = new import_obsidian12.Setting(this.container).setName(t2("rule.path.name")).addDropdown(
      (e) => e.addOptions({ white: t2("rule.path.white.name"), black: t2("rule.path.black.name") }).setValue(this.item.get("mode").value()).onChange((e2) => {
        this.item.get("mode").set(e2);
        this.updateDesc();
      })
    ).addTextArea(
      (e) => e.setValue(this.item.get("values").value().join("\n")).onChange((e2) => this.item.get("values").set(e2.split("\n").filter((e3) => e3)))
    );
    this.updateDesc();
  }
  support(k) {
    return k === "paths";
  }
  updateDesc() {
    const descriptions = {
      white: t2("rule.path.white.desc"),
      black: t2("rule.path.black.desc")
    };
    this.settings.setDesc(descriptions[this.item.get("mode").value()]);
  }
};
RulesPathsBuilder = __decorateClass([
  injectable()
], RulesPathsBuilder);

// src/Settings/SettingBuilders/Processor/ProcessorBuilder.ts
var import_obsidian13 = require("obsidian");

// src/Components/Processor/ProcessorUtils.ts
var ProcessorTypes = /* @__PURE__ */ ((ProcessorTypes2) => {
  ProcessorTypes2["Function"] = "function";
  ProcessorTypes2["Replace"] = "replace";
  return ProcessorTypes2;
})(ProcessorTypes || {});

// src/Settings/SettingBuilders/Processor/ProcessorBuilder.ts
var ProcessorBuilder = class extends AbstractBuilder2 {
  constructor() {
    super(...arguments);
    this.lastArgs = {};
  }
  support(k) {
    return k === "processor";
  }
  doBuild() {
    const fragment = createFragment(
      (e) => e.createEl("a", {
        text: t2("processor.name"),
        href: GITHUB_DOCS + "Processor.md"
      })
    );
    this.setting = new import_obsidian13.Setting(this.container).setName(fragment);
    this.buildDynamic();
  }
  updateDesc() {
    const fragment = createFragment();
    fragment.appendText(t2("processor.desc"));
    let additional = [];
    switch (this.item.get("type").value()) {
      case "replace" /* Replace */:
        additional = [
          "",
          t2("processor.replace.desc"),
          "title.replace(",
          createSpan(
            "",
            (e) => e.innerHTML = "&emsp;new RegExp(<br>&emsp;&emsp;#pattern#, <br>&emsp;&emsp;#flags#<br>&emsp;),"
          ),
          createSpan("", (e) => e.innerHTML = "&emsp;#replacement#"),
          ")"
        ];
        break;
      case "function" /* Function */:
        additional = [
          "",
          t2("processor.function.desc"),
          `const value = new Function('title', #${t2("processor.function.valueDesc")}#)`
        ];
        break;
    }
    additional.forEach((e) => {
      fragment.appendChild(createEl("br"));
      typeof e === "string" ? fragment.appendText(e) : fragment.appendChild(e);
    });
    this.setting.setDesc(fragment);
  }
  buildDynamic() {
    this.updateDesc();
    this.setting.addDropdown(
      (c) => {
        var _a;
        return c.addOptions({
          "": t2("disabled"),
          ["replace" /* Replace */]: t2("processor.replace.name"),
          ["function" /* Function */]: t2("processor.function.name")
        }).setValue((_a = this.item.get("type").value()) != null ? _a : "").onChange((v) => {
          var _a2, _b;
          const value = v === "" ? null : v;
          const type = this.item.get("type").value();
          this.lastArgs[type] = [...this.item.get("args").value()];
          this.item.get("type").set(value);
          this.item.get("args").set([...(_b = (_a2 = this.lastArgs) == null ? void 0 : _a2[value]) != null ? _b : []]);
          this.setting.controlEl.innerHTML = "";
          this.buildDynamic();
        });
      }
    );
    this.setAlignItemsMode("center");
    switch (this.item.get("type").value()) {
      case "function" /* Function */:
        this.setAlignItemsMode("start");
        return this.buildFunction();
      case "replace" /* Replace */:
        this.setAlignItemsMode("start");
        return this.buildReplace();
    }
  }
  setAlignItemsMode(mode) {
    this.setting.settingEl.style.alignItems = mode;
    this.setting.controlEl.style.alignItems = mode;
  }
  buildReplace() {
    const items = [
      {
        name: t2("processor.replace.pattern.name"),
        desc: t2("processor.replace.pattern.desc")
      },
      { name: t2("processor.replace.flags.name"), desc: t2("processor.replace.flags.desc") },
      { name: t2("processor.replace.replacement.name"), desc: t2("processor.replace.replacement.desc") }
    ];
    const container = createDiv({ attr: { style: "margin-left: 20px" } });
    let margin = "10px";
    const value = this.item.get("args").value();
    for (const [i, item] of items.entries()) {
      const c = createDiv({
        attr: { style: `margin-bottom: ${margin}` }
      });
      margin = "0px";
      c.appendChild(
        createDiv(
          {
            attr: { style: "display: flex; align-items: center; justify-content: space-between;" }
          },
          (e) => {
            var _a;
            e.appendChild(
              createDiv({ attr: { style: "margin-right: 10px" } }, (e2) => e2.appendText(`${item.name}:`))
            );
            new import_obsidian13.TextComponent(e).setValue((_a = value == null ? void 0 : value[i]) != null ? _a : "").onChange((e2) => value.splice(i, 1, e2)).onChanged();
          }
        )
      );
      c.appendChild(
        createDiv(
          { cls: "setting-item-description", attr: { style: "text-align: left" } },
          (e) => e.appendText(item.desc)
        )
      );
      container.appendChild(c);
    }
    this.setting.controlEl.prepend(container);
  }
  buildFunction() {
    this.setting.addTextArea(
      (e) => e.setValue(this.item.get("args").value().join()).onChange((e2) => this.item.get("args").set([e2]))
    );
  }
};

// src/Settings/FeatureBuilder/NoteLinkBuilder.ts
var import_obsidian14 = require("obsidian");
var NoteLinkBuilder = class extends AbstractBuilder {
  build({ id: id3, name, desc, settings, doc }) {
    var _a;
    this.id = id3;
    const fragment = createFragment((e) => e.createEl("a", { text: name, href: doc.link }));
    this.setting = new import_obsidian14.Setting(this.context.getContainer()).setName(fragment).setDesc(desc);
    this.setting.addDropdown((e) => this.strategy = e);
    this.strategy.addOptions({
      ["all" /* All */]: t2("feature.noteLink.strategy.all"),
      ["onlyEmpty" /* OnlyEmpty */]: t2("feature.noteLink.strategy.onlyEmpty")
    }).setValue((_a = settings.strategy) != null ? _a : "onlyEmpty" /* OnlyEmpty */).onChange(this.onChange.bind(this));
    this.setting.addDropdown((e) => this.approval = e);
    this.approval.addOptions({ Y: t2("feature.noteLink.approval.showModal"), N: t2("feature.noteLink.approval.auto") }).setValue(settings.approval ? "Y" : "N").onChange(this.onChange.bind(this));
    this.setting.addToggle((e) => this.toggle = e);
    this.toggle.setValue(settings.enabled).onChange(this.onChange.bind(this));
  }
  onChange() {
    this.context.getDispatcher().dispatch(
      "settings:tab:feature:changed",
      new Event({
        id: this.id,
        value: {
          enabled: this.toggle.getValue(),
          approval: this.approval.getValue() === "Y",
          strategy: this.strategy.getValue()
        }
      })
    );
  }
};

// config/services/settings.config.ts
var settings_config_default = (c) => {
  c.bind(inversify_types_default["settings:feature:builder"]).toDynamicValue(() => new DefaultBuilder()).whenTargetNamed("default");
  c.bind(inversify_types_default["settings:feature:builder"]).toDynamicValue(() => new AliasBuilder()).whenTargetNamed("alias" /* Alias */);
  c.bind(inversify_types_default["settings:feature:builder"]).toDynamicValue(() => new ExplorerSortBuilder()).whenTargetNamed("explorer:sort" /* ExplorerSort */);
  c.bind(inversify_types_default["settings:feature:builder"]).toDynamicValue(() => new NoteLinkBuilder()).whenTargetNamed("noteLink" /* NoteLink */);
  c.bind(inversify_types_default["factory:settings:feature:builder"]).toFunction(
    (name) => c.isBoundNamed(inversify_types_default["settings:feature:builder"], name) ? c.getNamed(inversify_types_default["settings:feature:builder"], name) : null
  );
  c.bind(inversify_types_default["settings:builder"]).to(TemplatesBuilder).whenTargetNamed("main");
  c.bind(inversify_types_default["settings:builder"]).to(FeaturesBuilder).whenTargetNamed("main");
  c.bind(inversify_types_default["settings:builder"]).to(UtilBuilder).whenTargetNamed("main");
  c.bind(inversify_types_default["settings:builder"]).to(RulesBuiler).whenTargetNamed("main");
  c.bind(inversify_types_default["settings:builder"]).to(ProcessorBuilder).whenTargetNamed("main");
  c.bind(inversify_types_default["settings:builder"]).to(RulesDelimiterBuilder).whenTargetNamed("rules");
  c.bind(inversify_types_default["settings:builder"]).to(RulesPathsBuilder).whenTargetNamed("rules");
  c.bind(inversify_types_default["factory:settings:builder"]).toFunction(
    (name) => c.getAllNamed(inversify_types_default["settings:builder"], name)
  );
};

// src/Components/Processor/ReplaceProcessor.ts
var ReplaceProcessor = class {
  constructor(args) {
    var _a, _b;
    try {
      this.pattern = new RegExp((_a = args == null ? void 0 : args[0]) != null ? _a : null, args == null ? void 0 : args[1]);
      this.replacement = (_b = args == null ? void 0 : args[2]) != null ? _b : null;
    } catch (e) {
      console.error(e);
    }
  }
  process(value) {
    return value.replace(this.pattern, this.replacement);
  }
};
ReplaceProcessor = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["processor:args"]))
], ReplaceProcessor);

// src/Components/Processor/FunctionProcessor.ts
var FunctionProcessor = class {
  constructor(args) {
    this.func = (args == null ? void 0 : args[0]) ? new Function("title", args[0]) : null;
  }
  process(value) {
    var _a, _b;
    return (_b = (_a = this.func) == null ? void 0 : _a.call(this, value)) != null ? _b : value;
  }
};
FunctionProcessor = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["processor:args"]))
], FunctionProcessor);

// config/services/processors.config.ts
var processors_config_default = new ContainerModule((bind) => {
  bind(inversify_types_default.processor).to(ReplaceProcessor).whenTargetNamed("replace" /* Replace */);
  bind(inversify_types_default.processor).to(FunctionProcessor).whenTargetNamed("function" /* Function */);
  bind(inversify_types_default["processor:args"]).toDynamicValue((c) => c.container.get(inversify_types_default["settings:storage"]).get("processor").get("args").value());
  bind(inversify_types_default["factory:processor"]).toAutoNamedFactory(inversify_types_default.processor);
});

// src/Resolver/ResolverService.ts
var ResolverService = class {
  constructor(factory, templateFactory, logger) {
    this.factory = factory;
    this.templateFactory = templateFactory;
    this.logger = logger;
    this.resolvers = /* @__PURE__ */ new Map();
  }
  create(template) {
    this.logger.log(`Create "${template}" template`);
    return this.getOrCreate(template);
  }
  createNamed(name) {
    this.logger.log(`Create named "${name}" template`);
    return this.create(this.templateFactory(name));
  }
  getOrCreate(template) {
    if (!this.resolvers.has(template)) {
      this.logger.log(`Create resolver for "${template}" template`);
      const resolver = this.factory();
      resolver.setTemplate(template);
      this.resolvers.set(template, resolver);
    }
    return this.resolvers.get(template);
  }
};
ResolverService = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:resolver:resolver"])),
  __decorateParam(1, inject(inversify_types_default["factory:resolver:template"])),
  __decorateParam(2, inject(inversify_types_default.logger)),
  __decorateParam(2, named("resolver:service"))
], ResolverService);

// src/Resolver/ResolverCachedProxy.ts
var ResolverCachedProxy = class {
  constructor(resolver, cache, dispatcher) {
    this.resolver = resolver;
    this.cache = cache;
    this.dispatcher = dispatcher;
    dispatcher.addListener({ name: "resolver:clear", cb: () => this.cache.clear(), sort: 0 });
    dispatcher.addListener({ name: "metadata:cache:changed", cb: (e) => this.handleDelete(e.get().path), sort: 0 });
    dispatcher.addListener({
      name: "file:rename",
      cb: (e) => {
        this.cache.delete(e.get().old);
        this.cache.save(this.cache.getItem(e.get().actual).set(null));
        this.handleDelete(e.get().actual);
      }
    });
  }
  handleDelete(path) {
    const item = this.cache.getItem(path);
    if (!item.isHit()) {
      return;
    }
    const old = item.get();
    this.actualize(item);
    if (old !== item.get()) {
      this.dispatcher.dispatch("resolver:unresolved", new Event({ path }));
    }
  }
  resolve(path) {
    return this.get(path);
  }
  actualize(item) {
    const title = this.resolver.resolve(item.getKey());
    this.cache.save(item.set(title));
  }
  get(path) {
    var _a;
    const item = this.cache.getItem(path);
    if (item.isHit() === false) {
      this.actualize(item);
    }
    return (_a = item.get()) != null ? _a : null;
  }
  setTemplate(template) {
    this.resolver.setTemplate(template);
  }
};
ResolverCachedProxy = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default.resolver)),
  __decorateParam(0, named("original")),
  __decorateParam(1, inject(inversify_types_default.cache)),
  __decorateParam(2, inject(inversify_types_default["event:dispatcher"]))
], ResolverCachedProxy);

// src/Resolver/Resolver.ts
var Resolver = class {
  constructor(filters, creator, dispatcher) {
    this.filters = filters;
    this.creator = creator;
    this.dispatcher = dispatcher;
    this.template = "";
  }
  setTemplate(template) {
    this.template = template;
  }
  resolve(path) {
    return this.valid(path) ? this.get(path) : null;
  }
  get(path) {
    var _a;
    try {
      return (_a = this.dispatch(this.creator.create(path, this.template))) != null ? _a : null;
    } catch (e) {
      console.error(`Error by path ${path}`, e);
    }
    return null;
  }
  dispatch(title) {
    var _a;
    const event = new Event({
      value: title,
      modify(v) {
        this.value = v;
      }
    });
    this.dispatcher.dispatch("resolver:resolved", event);
    return (_a = event.get().value) != null ? _a : null;
  }
  valid(path) {
    for (const filter of this.filters) {
      if (filter.check(path) === false) {
        return false;
      }
    }
    return true;
  }
};
Resolver = __decorateClass([
  injectable(),
  __decorateParam(0, multiInject(inversify_types_default.filter)),
  __decorateParam(1, inject(inversify_types_default["creator:creator"])),
  __decorateParam(2, inject(inversify_types_default["event:dispatcher"]))
], Resolver);

// config/services/resolver.config.ts
var resolver_config_default = new ContainerModule((bind) => {
  bind(inversify_types_default["factory:resolver:template"]).toFactory((c) => (value) => {
    var _a, _b;
    const storage = c.container.get(inversify_types_default["settings:storage"]);
    const [name, type] = value.split(":");
    const targetTemplates = storage.get("templates").get(name);
    return (_b = (_a = targetTemplates == null ? void 0 : targetTemplates.get(type)) == null ? void 0 : _a.value()) != null ? _b : storage.get("templates").get("common").get(type).value();
  });
  bind(inversify_types_default.resolver).to(ResolverCachedProxy).whenTargetIsDefault();
  bind(inversify_types_default.resolver).to(Resolver).whenTargetNamed("original");
  bind(inversify_types_default["resolver:service"]).to(ResolverService).inSingletonScope();
  bind(
    inversify_types_default["factory:resolver:resolver"]
  ).toFactory((c) => () => c.container.get(inversify_types_default.resolver));
});

// src/Components/ApiAdapter/Api.ts
var Api = class {
  constructor(factory, dispatcher, composer) {
    this.factory = factory;
    this.dispatcher = dispatcher;
    this.composer = composer;
  }
  getResolverFactory() {
    return this.factory;
  }
  getEventDispatcher() {
    return this.dispatcher;
  }
  getEnabledFeatures() {
    return this.composer.getIds();
  }
};
Api = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["feature:service"])),
  __decorateParam(1, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(2, inject(inversify_types_default["feature:composer"]))
], Api);

// src/Components/ApiAdapter/Defer.ts
var DeferPluginReady = 2;
var DeferFeaturesReady = 4;
var Defer = class {
  constructor(factory) {
    this.factory = factory;
    this.state = 0;
    this.promises = {
      plugin: null,
      managers: null
    };
    this.resolves = {
      plugin: null,
      managers: null
    };
    this.promises.plugin = new Promise((r) => this.resolves.plugin = r);
    this.promises.managers = new Promise((r) => this.resolves.managers = r);
  }
  setFlag(flag) {
    if (!(this.state & flag)) {
      this.state = this.state | flag;
      this.processState();
    }
  }
  processState() {
    if (this.isPluginReady()) {
      this.resolves.plugin();
      if (this.isFeaturesReady()) {
        this.resolves.managers();
      }
    }
  }
  async awaitPlugin() {
    return await this.promises.plugin;
  }
  async awaitFeatures() {
    return this.promises.managers;
  }
  isPluginReady() {
    return (this.state & DeferPluginReady) !== 0;
  }
  isFeaturesReady() {
    return (this.state & DeferFeaturesReady) !== 0;
  }
  getApi() {
    return this.isPluginReady() ? this.factory() : null;
  }
};
Defer = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["factory:api"]))
], Defer);

// config/services/api.adapter.config.ts
var api_adapter_config_default = new ContainerModule((bind) => {
  bind(inversify_types_default.api).to(Api).inSingletonScope();
  bind(inversify_types_default["factory:api"]).toFactory((c) => () => c.container.get(inversify_types_default.api));
  bind(inversify_types_default.defer).to(Defer).inSingletonScope();
});

// src/Filters/ExtensionFilter.ts
var ExtensionFilter = class {
  check(path) {
    return /.*\.md$/.test(path);
  }
};
ExtensionFilter = __decorateClass([
  injectable()
], ExtensionFilter);

// src/Filters/PathListFilter.ts
var PathListFilter = class {
  constructor(list) {
    this.list = list;
  }
  check(path) {
    return this.list.isFileAllowed(path);
  }
};
PathListFilter = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["component:black_white_list"]))
], PathListFilter);

// src/Components/BlackWhiteList/BlackWhiteList.ts
var BlackWhiteList = class {
  constructor() {
    this.mode = "black";
    this.list = [];
  }
  get default() {
    return this.mode === "black";
  }
  isFileAllowed(path) {
    if (this.list.length === 0) {
      return true;
    }
    for (const item of this.list) {
      if (path.startsWith(item)) {
        return this.mode === "white";
      }
    }
    return this.default;
  }
  setMode(mode) {
    this.mode = mode;
  }
  setList(list) {
    this.list = [...list];
  }
};
BlackWhiteList = __decorateClass([
  injectable()
], BlackWhiteList);

// src/Components/Cache/CacheItem.ts
var CacheItem = class {
  constructor(_isHit, value, key) {
    this._isHit = _isHit;
    this.value = value;
    this.key = key;
  }
  get() {
    return this.value;
  }
  isHit() {
    return this._isHit;
  }
  set(value) {
    this.value = value;
    return this;
  }
  getKey() {
    return this.key;
  }
};

// src/Components/Cache/Cache.ts
var Cache = class {
  constructor() {
    this.pool = /* @__PURE__ */ new Map();
    this.serialized = /* @__PURE__ */ new Map();
  }
  clear() {
    this.pool.clear();
    this.serialized.clear();
  }
  delete(key) {
    this.pool.delete(key);
    this.serialized.delete(key);
  }
  getItem(key) {
    const isHit = this.pool.has(key) || this.serialized.has(key);
    const value = isHit ? this.resolve(key) : null;
    return new CacheItem(isHit, value, key);
  }
  resolve(key) {
    if (this.pool.has(key)) {
      return this.pool.get(key);
    }
    return JSON.parse(this.serialized.get(key));
  }
  save(item) {
    const key = item.getKey();
    const value = item.get();
    this.pool.delete(key);
    this.serialized.delete(key);
    if (this.isObject(value)) {
      if (!this.canBeSerialized(value)) {
        throw new Error("Object with functions can not be serialized");
      }
      this.serialized.set(key, JSON.stringify(value));
    } else {
      this.pool.set(key, value);
    }
  }
  isObject(value) {
    return typeof value === "object" && ![null, void 0].includes(value);
  }
  canBeSerialized(object) {
    return !ObjectHelper.values(object).some(
      (e) => this.isObject(e) ? !this.canBeSerialized(e) : typeof e === "function"
    );
  }
};
Cache = __decorateClass([
  injectable()
], Cache);

// src/Components/Extractor/Extractor.ts
var Extractor = class {
  constructor(strategies) {
    this.strategies = strategies;
  }
  /**
   * @throws {PathNotFoundException}
   * @throws {TypeNotSupportedException}
   * @param path
   * @param obj
   */
  extract(path, obj) {
    const parts = path.split(".");
    let part;
    let extracted = obj;
    while (part = parts.shift()) {
      extracted = this.extractInternal(part, extracted);
    }
    let strategy = null;
    let type = extracted === null ? "null" : typeof extracted;
    type = type === "object" && Array.isArray(extracted) ? "array" : type;
    for (const item of this.strategies) {
      if (item.support(type)) {
        strategy = item;
        break;
      }
    }
    if (strategy === null) {
      throw new TypeNotSupportedException(`Type ${type} is not supported`);
    }
    return strategy.process(extracted);
  }
  /**
   * @throws {PathNotFoundException}
   * @param key
   * @param obj
   * @private
   */
  extractInternal(key, obj) {
    if (obj === void 0 || (obj == null ? void 0 : obj[key]) === void 0) {
      throw new PathNotFoundException(`Key ${key} not found`);
    }
    return obj[key];
  }
};
Extractor = __decorateClass([
  injectable(),
  __decorateParam(0, multiInject(inversify_types_default["component:extractor:strategy"]))
], Extractor);

// src/Components/Extractor/LiteralStrategy.ts
var LiteralStrategy = class {
  support(type) {
    return ["number", "string"].includes(type);
  }
  process(v) {
    return v.toString();
  }
};
LiteralStrategy = __decorateClass([
  injectable()
], LiteralStrategy);

// src/Components/Extractor/ArrayStrategy.ts
var ArrayStrategy = class {
  constructor(delimiterGetter) {
    this.delimiterGetter = delimiterGetter;
  }
  process(v) {
    if (v.length === 0) {
      return null;
    }
    const delimiter = this.delimiterGetter();
    return !delimiter.enabled ? v[0] : v.join(delimiter.value);
  }
  support(type) {
    return type === "array";
  }
};
ArrayStrategy = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["getter:delimiter"]))
], ArrayStrategy);

// src/Components/Extractor/NullStrategy.ts
var NullStrategy = class {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  process(v) {
    return null;
  }
  support(type) {
    return type === "null";
  }
};
NullStrategy = __decorateClass([
  injectable()
], NullStrategy);

// src/Components/Debug/Debugger.ts
var Debugger = class {
  constructor(name, enabled) {
    this.name = name;
    this.enabled = enabled;
  }
  log(...value) {
    if (this.enabled()) {
      console.debug(`[${this.name}]`, ...value);
    }
  }
};
Debugger = __decorateClass([
  injectable()
], Debugger);

// src/Components/Debug/LoggerComposer.ts
var LoggerComposer = class {
  constructor() {
    this.loggers = /* @__PURE__ */ new Map();
    this.enabled = false;
  }
  create(name) {
    if (!this.loggers.has(name)) {
      this.loggers.set(name, new Debugger(name, this.isEnabled.bind(this)));
    }
    return this.loggers.get(name);
  }
  isEnabled() {
    return this.enabled;
  }
  enable() {
    this.enabled = true;
  }
  disable() {
    this.enabled = false;
  }
};
LoggerComposer = __decorateClass([
  injectable()
], LoggerComposer);

// src/Utils/FileNoteLinkService.ts
var import_obsidian15 = require("obsidian");
var FileNoteLinkService = class {
  constructor(facade) {
    this.facade = facade;
    this.REGEXP = /^\[\[.+\]\]$/;
  }
  getNoteLinks(path) {
    var _a;
    const links = this.facade.getFileLinksCache(path);
    const result = [];
    for (const link of links) {
      if (!this.REGEXP.test(link.original)) {
        continue;
      }
      const file = this.facade.getFirstLinkpathDest(link.link, path);
      if (file instanceof import_obsidian15.TFile === false) {
        continue;
      }
      result.push({
        dest: file.path,
        link: link.link,
        original: link.original,
        alias: (_a = link == null ? void 0 : link.displayText) != null ? _a : null
      });
    }
    return result;
  }
};
FileNoteLinkService = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["facade:obsidian"]))
], FileNoteLinkService);

// src/Components/EventDispatcher/EventDispatcher.ts
var EventDispatcher = class {
  constructor(logger) {
    this.logger = logger;
    this.events = /* @__PURE__ */ new Map();
  }
  addListener({ name, cb, sort = null, once = false }) {
    var _a, _b, _c;
    const ref = { getName: () => name };
    const events = (_a = this.events.get(name)) != null ? _a : [];
    sort = sort != null ? sort : ((_c = (_b = events[0]) == null ? void 0 : _b.sort) != null ? _c : 0) + 1;
    const event = { cb, sort, ref, once };
    events.push(event);
    events.sort((a, b) => a.sort - b.sort);
    this.logger.log(`Added listener: ${name.toString()}`, event);
    this.events.set(name, events);
    return ref;
  }
  dispatch(name, e) {
    var _a, _b;
    this.logger.log(name);
    let shift = 0;
    for (const [i, item] of [...(_b = (_a = this.events.get(name)) == null ? void 0 : _a.entries()) != null ? _b : []]) {
      item.cb(e);
      if (item.once) {
        this.events.get(name).splice(i - shift++, 1);
      }
    }
  }
  removeListener(ref) {
    for (const [i, item] of this.events.get(ref.getName()).entries()) {
      if (item.ref === ref) {
        this.events.get(ref.getName()).splice(i, 1);
        this.logger.log(`Removed listener: ${ref.getName().toString()}`);
        return;
      }
    }
  }
};
EventDispatcher = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default.logger)),
  __decorateParam(0, named("event:dispatcher"))
], EventDispatcher);

// src/Components/BlackWhiteList/BlackWhiteListListener.ts
var BlackWhiteListListener = class {
  constructor(component, dispatcher) {
    this.component = component;
    this.dispatcher = dispatcher;
    this.ref = null;
  }
  bind() {
    this.ref = this.dispatcher.addListener({ name: "settings:changed", cb: (e) => this.handle(e.get()) });
    this.dispatcher.addListener({
      name: "settings.loaded",
      once: true,
      cb: (e) => {
        this.component.setMode(e.get().settings.rules.paths.mode);
        this.component.setList(e.get().settings.rules.paths.values);
      }
    });
  }
  handle({ changed, actual }) {
    var _a, _b, _c, _d;
    if ((_b = (_a = changed == null ? void 0 : changed.rules) == null ? void 0 : _a.paths) == null ? void 0 : _b.values) {
      this.component.setList(actual.rules.paths.values);
    }
    if ((_d = (_c = changed == null ? void 0 : changed.rules) == null ? void 0 : _c.paths) == null ? void 0 : _d.mode) {
      this.component.setMode(actual.rules.paths.mode);
    }
  }
  unbind() {
    this.dispatcher.removeListener(this.ref);
    this.ref = null;
  }
};
BlackWhiteListListener = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["component:black_white_list"])),
  __decorateParam(1, inject(inversify_types_default["event:dispatcher"]))
], BlackWhiteListListener);

// src/Components/Processor/ProccessorListener.ts
var ProcessorListener = class {
  constructor(dispatcher, factory) {
    this.dispatcher = dispatcher;
    this.factory = factory;
    this.changedRef = null;
    this.resolvedRef = null;
    this.processor = null;
  }
  bind() {
    this.changedRef = this.dispatcher.addListener({ name: "settings:changed", cb: (e) => this.make(e.get().actual) });
    this.dispatcher.addListener({ name: "settings.loaded", cb: (e) => this.make(e.get().settings), once: true });
  }
  unbind() {
    this.dispatcher.removeListener(this.changedRef);
    this.changedRef = null;
    this.disable();
  }
  make(actual) {
    const { type, args } = actual.processor;
    if (Object.values(ProcessorTypes).includes(type)) {
      this.enable(type, args);
    } else {
      this.disable();
    }
  }
  disable() {
    if (this.resolvedRef) {
      this.dispatcher.removeListener(this.resolvedRef);
      this.resolvedRef = null;
    }
    this.processor = null;
  }
  enable(type, args) {
    this.processor = this.factory(type, args);
    if (this.resolvedRef === null) {
      this.resolvedRef = this.dispatcher.addListener({
        name: "resolver:resolved",
        cb: this.handleResolved.bind(this)
      });
    }
  }
  handleResolved(event) {
    var _a, _b;
    const obj = event.get();
    if (typeof obj.value !== "string") {
      return;
    }
    const value = (_b = (_a = this.processor) == null ? void 0 : _a.process(obj.value)) != null ? _b : null;
    if (value) {
      obj.modify(value);
    }
  }
};
ProcessorListener = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default["event:dispatcher"])),
  __decorateParam(1, inject(inversify_types_default["factory:processor"]))
], ProcessorListener);

// src/Utils/FakeTitleElementService.ts
var FakeTitleElementService = class {
  constructor() {
    this.attr = {
      fake: "ofmt-fake-id",
      original: "ofmt-original-id"
    };
    this.elements = /* @__PURE__ */ new Map();
    //TODO: add logs for events
    this.events = {
      click: (e) => {
        const id3 = this.extractId(e.target);
        this.setVisible(id3, false).getOriginal(id3).focus();
      },
      blur: (e) => this.setVisible(this.extractId(e.target), true),
      hover: (e) => this.setVisible(this.extractId(e.target), false),
      out: (e) => this.setVisible(this.extractId(e.target), true)
    };
  }
  extractId(e) {
    var _a;
    if (e instanceof HTMLElement) {
      return (_a = e.getAttribute(this.attr.fake)) != null ? _a : e.getAttribute(this.attr.original);
    }
    return null;
  }
  getOriginal(id3) {
    var _a, _b;
    return (_b = (_a = this.elements.get(id3)) == null ? void 0 : _a.original) != null ? _b : null;
  }
  has(id3) {
    return this.elements.has(id3);
  }
  removeExcept(id3) {
    const ids = Array.isArray(id3) ? id3 : [id3];
    for (const [key, { fake }] of this.elements.entries()) {
      if (!ids.includes(key)) {
        fake.remove();
        this.elements.delete(key);
      }
    }
  }
  remove(id3) {
    if (!this.has(id3)) {
      return;
    }
    this.setVisible(id3, false);
    const { fake, events = [], original } = this.elements.get(id3);
    events.forEach((e) => {
      if (e === "click") {
        original.removeEventListener("click", this.events.blur);
      }
      if (e === "hover") {
        original.removeEventListener("mouseout", this.events.out);
      }
    });
    original.removeAttribute(this.attr.original);
    fake.remove();
    this.elements.delete(id3);
  }
  removeAll() {
    Array.from(this.elements.keys()).forEach((e) => this.remove(e));
  }
  getOrCreate({
    original,
    title,
    id: id3,
    events = []
  }) {
    const container = original == null ? void 0 : original.parentElement;
    if (!container) {
      return;
    }
    let element = this.find(container, id3);
    if (element) {
      element.setText(title);
      return { created: false, element };
    }
    element = document.createElement(original.tagName);
    element.className = original.className;
    element.setText(title);
    element.setAttribute(this.attr.fake, id3);
    original.setAttribute(this.attr.original, id3);
    this.elements.set(id3, { original, fake: element, events: [...events] });
    if (events.contains("click")) {
      this.bindClick(id3);
    }
    if (events.contains("hover")) {
      this.bindHover(id3);
    }
    container.insertBefore(element, original);
    return { created: true, element };
  }
  setVisible(id3, visible) {
    if (this.elements.has(id3)) {
      const { fake, original } = this.elements.get(id3);
      original.hidden = visible;
      fake.hidden = !visible;
    }
    return this;
  }
  bindClick(id3) {
    if (this.has(id3)) {
      const { fake, original } = this.elements.get(id3);
      fake.addEventListener("click", this.events.click);
      original.addEventListener("blur", this.events.blur);
    }
  }
  bindHover(id3) {
    if (this.has(id3)) {
      const { fake, original } = this.elements.get(id3);
      fake.addEventListener("mouseover", this.events.hover);
      original.addEventListener("mouseout", this.events.out);
    }
  }
  find(container, id3) {
    for (const node of Array.from(container.children)) {
      const cId = node.getAttribute(this.attr.fake);
      if (id3 === cId && node instanceof HTMLElement) {
        return node;
      }
    }
    return null;
  }
};
FakeTitleElementService = __decorateClass([
  injectable()
], FakeTitleElementService);

// src/Components/Extractor/BooleanStrategy.ts
var BooleanStrategy = class {
  process(v) {
    return v ? "true" : "false";
  }
  support(type) {
    return "boolean" === type;
  }
};
BooleanStrategy = __decorateClass([
  injectable()
], BooleanStrategy);

// src/Utils/ResultDomWrapper.ts
var ResultDomWrapper = class {
  constructor(resolver = null, dom) {
    this.resolver = resolver;
    this.replacer = null;
    this.replacer = FunctionReplacer.create(dom, "addResult", this, (self2, defaultArgs, vanilla) => {
      const c = vanilla.call(dom, ...defaultArgs);
      const file = defaultArgs[0];
      self2.processLookupItem(file, c);
      return c;
    });
    this.replacer.enable();
    this.process();
  }
  disable() {
    this.replacer.disable();
    this.replacer = null;
  }
  process() {
    var _a, _b, _c;
    const lookup = (_c = (_b = (_a = this.replacer) == null ? void 0 : _a.getTarget()) == null ? void 0 : _b.resultDomLookup) != null ? _c : /* @__PURE__ */ new Map();
    for (const [file, item] of lookup) {
      this.processLookupItem(file, item);
    }
  }
  processLookupItem(file, item) {
    var _a, _b;
    const restore = !((_a = this == null ? void 0 : this.replacer) == null ? void 0 : _a.isEnabled());
    if (file.extension !== "md") {
      return;
    }
    const node = item.containerEl.firstElementChild.find(".tree-item-inner");
    const text = (_b = restore ? null : this.resolver.resolve(file.path)) != null ? _b : file.basename;
    if (node.getText() !== text) {
      node.setText(text);
    }
  }
};

// src/Utils/SearchDomWrapperService.ts
var SearchDomWrapperService = class {
  constructor(logger) {
    this.logger = logger;
    this.entities = /* @__PURE__ */ new Map();
    this.timer = null;
  }
  wrapDom(dom, resolver, tag) {
    if (!this.entities.has(tag)) {
      this.entities.set(tag, /* @__PURE__ */ new Map());
    }
    const tagged = this.entities.get(tag);
    if (!tagged.has(dom)) {
      const wrapper = new ResultDomWrapper(resolver, dom);
      tagged.set(dom, wrapper);
      this.logger.log(`Entity created`);
      this.runTimer();
    }
  }
  destroyByTag(tag) {
    if (!this.entities.has(tag)) {
      return;
    }
    for (const [dom, wrapper] of this.entities.get(tag)) {
      wrapper.disable();
      this.entities.get(tag).delete(dom);
    }
  }
  runTimer() {
    if (this.timer) {
      clearTimeout(this.timer);
    }
    this.timer = setTimeout(this.selfClean.bind(this), 1e4);
  }
  selfClean() {
    this.timer = null;
    for (const [tag, entities] of this.entities) {
      this.logger.log(`Tag ${tag} has ${entities.size} entities before self-clean`);
      for (const [dom, wrapper] of entities) {
        if (!document.body.contains(dom.el)) {
          wrapper.disable();
          this.logger.log(`Dom from ${tag} tag has been removed`);
          this.entities.get(tag).delete(dom);
        }
      }
      this.logger.log(`Tag ${tag} has ${entities.size} entities after self-clean`);
    }
  }
};
SearchDomWrapperService = __decorateClass([
  injectable(),
  __decorateParam(0, inject(inversify_types_default.logger)),
  __decorateParam(0, named(SearchDomWrapperService.name))
], SearchDomWrapperService);

// config/inversify.config.ts
var Container2 = new Container();
Container2.bind(inversify_types_default["event:dispatcher"]).to(EventDispatcher).inSingletonScope();
Container2.bind(inversify_types_default["template:pattern"]).toConstantValue("(?<placeholder>{{[^{}]+?}})");
Container2.bind(inversify_types_default.filter).to(ExtensionFilter);
Container2.bind(inversify_types_default.filter).to(PathListFilter);
Container2.bind(inversify_types_default["component:black_white_list"]).to(BlackWhiteList).inSingletonScope();
Container2.bind(inversify_types_default.cache).to(Cache);
Container2.bind(inversify_types_default["component:extractor"]).to(Extractor);
Container2.bind(inversify_types_default["component:extractor:strategy"]).to(LiteralStrategy);
Container2.bind(inversify_types_default["component:extractor:strategy"]).to(ArrayStrategy);
Container2.bind(inversify_types_default["component:extractor:strategy"]).to(NullStrategy);
Container2.bind(inversify_types_default["component:extractor:strategy"]).to(BooleanStrategy);
Container2.bind(inversify_types_default["logger:composer"]).to(LoggerComposer).inSingletonScope();
Container2.bind(inversify_types_default.logger).toDynamicValue((context) => {
  return context.container.get(inversify_types_default["logger:composer"]).create(context.currentRequest.target.getNamedTag().value);
}).when(() => true);
Container2.bind(inversify_types_default["service:note:link"]).to(FileNoteLinkService).inSingletonScope();
Container2.bind(inversify_types_default["service:fake_title_element"]).to(FakeTitleElementService);
Container2.bind(inversify_types_default.listener).to(BlackWhiteListListener).whenTargetNamed("unnamed");
Container2.bind(inversify_types_default.listener).to(ProcessorListener).whenTargetNamed("unnamed");
Container2.load(creator_config_default);
feature_config_default(Container2);
settings_config_default(Container2);
Container2.load(processors_config_default);
Container2.load(resolver_config_default);
Container2.load(api_adapter_config_default);
Container2.bind(inversify_types_default["factory:replacer"]).toFunction(
  (t3, m, a, i) => FunctionReplacer.create(t3, m, a, i)
);
Container2.bind(inversify_types_default["service:search:dom:wrapper"]).to(SearchDomWrapperService).inSingletonScope();
var inversify_config_default = Container2;

// src/App.ts
var App2 = class {
  constructor() {
    this.container = inversify_config_default;
    this.bind();
  }
  bind() {
    const dispatcher = this.container.get(inversify_types_default["event:dispatcher"]);
    dispatcher.addListener({
      name: "settings:changed",
      cb: (e) => this.onSettingsChanged(e.get())
    });
    dispatcher.addListener({
      name: "settings.loaded",
      once: true,
      cb: (e) => this.init(e.get().settings)
    });
  }
  init(settings) {
    this.container.bind(inversify_types_default.delimiter).toConstantValue(settings.rules.delimiter);
    this.container.get(inversify_types_default["logger:composer"])[settings.debug ? "enable" : "disable"]();
  }
  onSettingsChanged({ actual, changed }) {
    var _a;
    if ((_a = changed == null ? void 0 : changed.rules) == null ? void 0 : _a.delimiter) {
      this.container.rebind(inversify_types_default.delimiter).toConstantValue(actual.rules.delimiter);
    }
    if (changed.debug) {
      this.container.get(inversify_types_default["logger:composer"])[actual.debug ? "enable" : "disable"]();
    }
    const dispatcher = this.container.get(inversify_types_default["event:dispatcher"]);
    dispatcher.dispatch("resolver:clear", null);
  }
};
App2 = __decorateClass([
  injectable()
], App2);

// src/Utils/PluginHelper.ts
var PluginHelper = class {
  static createDefaultSettings() {
    return {
      templates: {
        common: { main: "title", fallback: "fallback_title" },
        ...Object.fromEntries(Object.values(Feature).map((e) => [e, { main: null, fallback: null }]))
      },
      rules: {
        paths: {
          mode: "black",
          values: []
        },
        delimiter: {
          enabled: false,
          value: ""
        }
      },
      debug: false,
      boot: {
        delay: 1e3
      },
      features: {
        ["alias" /* Alias */]: {
          enabled: false,
          strategy: "ensure" /* Ensure */,
          validator: "fr" /* FrontmatterRequired */
        },
        ["explorer" /* Explorer */]: { enabled: false },
        ["explorer:sort" /* ExplorerSort */]: { enabled: false },
        ["tab" /* Tab */]: { enabled: false },
        ["header" /* Header */]: { enabled: false },
        ["graph" /* Graph */]: { enabled: false },
        ["starred" /* Starred */]: { enabled: false },
        ["search" /* Search */]: { enabled: false },
        ["suggest" /* Suggest */]: { enabled: false },
        ["inlineTitle" /* InlineTitle */]: { enabled: false },
        ["canvas" /* Canvas */]: { enabled: false },
        ["backlink" /* Backlink */]: { enabled: false },
        ["noteLink" /* NoteLink */]: { enabled: false, strategy: "onlyEmpty" /* OnlyEmpty */, approval: true }
      },
      processor: {
        args: [],
        type: null
      }
    };
  }
};

// src/Obsidian/ObsidianFacade.ts
var import_obsidian16 = require("obsidian");
var ObsidianFacade = class {
  constructor(app) {
    this.app = app;
  }
  isInternalPluginEnabled(id3) {
    return this.app.internalPlugins.getEnabledPluginById(id3) !== null;
  }
  getTFile(path) {
    const file = this.app.vault.getAbstractFileByPath(path);
    return file instanceof import_obsidian16.TFile ? file : null;
  }
  getFileContent(file) {
    return this.app.vault.cachedRead(file);
  }
  modifyFile(file, c) {
    return this.app.vault.modify(file, c);
  }
  getFileCache(path) {
    return this.app.metadataCache.getCache(path);
  }
  getFileLinksCache(path) {
    var _a, _b;
    return (_b = (_a = this.getFileCache(path)) == null ? void 0 : _a.links) != null ? _b : [];
  }
  getLeavesOfType(type) {
    return this.app.workspace.getLeavesOfType(type);
  }
  getViewsOfType(type) {
    return this.getLeavesOfType(type).map((e) => e.view);
  }
  getFirstLinkpathDest(linkpath, from) {
    return this.app.metadataCache.getFirstLinkpathDest(linkpath, from);
  }
  getActiveLeaf() {
    var _a, _b;
    return (_b = (_a = this.app.workspace) == null ? void 0 : _a.activeLeaf) != null ? _b : null;
  }
};

// main.ts
var MetaTitlePlugin = class extends import_obsidian17.Plugin {
  constructor() {
    super(...arguments);
    this.container = inversify_config_default;
  }
  getDefer() {
    return this.container.get(inversify_types_default.defer);
  }
  async loadSettings() {
    var _a, _b, _c, _d;
    const loaded = await this.loadData();
    if (Array.isArray(loaded == null ? void 0 : loaded.templates)) {
      loaded.templates = {
        ...PluginHelper.createDefaultSettings().templates,
        common: { main: (_b = (_a = loaded.templates) == null ? void 0 : _a[0]) != null ? _b : "title", fallback: (_d = (_c = loaded.templates) == null ? void 0 : _c[1]) != null ? _d : "" }
      };
    }
    const data = ObjectHelper.fillFrom(PluginHelper.createDefaultSettings(), loaded != null ? loaded : {});
    this.storage = new Storage(data);
    this.container.bind(inversify_types_default["settings:storage"]).toConstantValue(this.storage);
    this.addSettingTab(this.container.resolve(SettingsTab).getTab());
  }
  async onSettingsChange(settings) {
    await this.saveData(settings);
    this.reloadFeatures();
    await this.mc.refresh();
  }
  async delay() {
    const delay = this.storage.get("boot").get("delay").value();
    this.logger.log(`Plugin manual delay ${delay}`);
    await new Promise((r) => setTimeout(r, delay));
  }
  async onload() {
    this.bindServices();
    this.dispatcher = this.container.get(inversify_types_default["event:dispatcher"]);
    this.logger = this.container.getNamed(inversify_types_default.logger, "main");
    this.app.workspace.on("layout-change", () => this.dispatcher.dispatch("layout:change", null));
    this.app.workspace.on("active-leaf-change", () => this.dispatcher.dispatch("active:leaf:change", null));
    this.app.workspace.on("file-open", (file) => this.dispatcher.dispatch("file:open", new Event(file)));
    new App2();
    this.container.getAllNamed(inversify_types_default.listener, "unnamed").map((e) => e.bind());
    await this.loadSettings();
    this.app.workspace.onLayoutReady(() => this.getDefer().setFlag(DeferPluginReady));
    await this.delay();
    this.fc = inversify_config_default.get(inversify_types_default["feature:composer"]);
    this.mc = inversify_config_default.get(inversify_types_default["manager:composer"]);
    this.bind();
    this.registerCommands();
  }
  bindServices() {
    inversify_config_default.bind(inversify_types_default["factory:obsidian:file"]).toFactory(
      () => (path) => this.app.vault.getAbstractFileByPath(path)
    );
    inversify_config_default.bind(inversify_types_default["factory:obsidian:meta"]).toFactory(
      () => (path, type) => {
        var _a;
        return (_a = this.app.metadataCache.getCache(path)) == null ? void 0 : _a[type];
      }
    );
    inversify_config_default.bind(inversify_types_default["facade:obsidian"]).toConstantValue(new ObsidianFacade(this.app));
    inversify_config_default.bind(inversify_types_default["factory:metadata:cache"]).toFunction(() => this.app.metadataCache);
    inversify_config_default.bind(inversify_types_default["obsidian:app"]).toConstantValue(this.app);
    inversify_config_default.bind(inversify_types_default["obsidian:plugin"]).toConstantValue(this);
    inversify_config_default.bind(inversify_types_default["newable:obsidian:chooser"]).toConstructor(
      //@ts-ignore
      Object.getPrototypeOf(this.app.workspace.editorSuggest.suggests[0].suggestions).constructor
    );
    inversify_config_default.bind(inversify_types_default["factory:obsidian:active:file"]).toFunction(() => this.app.workspace.getActiveFile());
    inversify_config_default.bind(inversify_types_default["factory:obsidian:modal"]).toFunction(() => new import_obsidian17.Modal(this.app));
  }
  onunload() {
    this.fc.disableAll();
  }
  bind() {
    this.registerEvent(
      this.app.metadataCache.on(
        "changed",
        (file, _, cache) => this.dispatcher.dispatch("metadata:cache:changed", new Event({ path: file.path, cache }))
      )
    );
    this.app.workspace.onLayoutReady(async () => {
      this.registerEvent(
        this.app.vault.on(
          "rename",
          ({ path: actual }, old) => this.dispatcher.dispatch("file:rename", new Event({ old, actual }))
        )
      );
      this.reloadFeatures();
      await this.mc.refresh();
      this.getDefer().setFlag(DeferFeaturesReady);
    });
    this.dispatcher.addListener({
      name: "resolver:unresolved",
      cb: (e) => this.mc.update(e.get().path).catch(console.error)
    });
    this.dispatcher.addListener({ name: "settings:changed", cb: (e) => this.onSettingsChange(e.get().actual) });
  }
  reloadFeatures() {
    this.fc.disableAll();
    const f = this.storage.get("features");
    const states = [];
    for (const feature of Object.values(Feature)) {
      states.push([feature, f.get(feature).get("enabled").value()]);
    }
    for (const [id3, state] of states) {
      this.fc.toggle(id3, state);
    }
  }
  registerCommands() {
    this.addCommand({
      id: "ofmt-features-disable",
      name: t2("command.features.disable"),
      callback: () => this.fc.disableAll()
    });
    this.addCommand({
      id: "ofmt-features-reload",
      name: t2("command.features.reload"),
      callback: () => {
        this.reloadFeatures();
        this.mc.refresh().catch(console.error);
      }
    });
  }
};
/*! Bundled license information:

reflect-metadata/Reflect.js:
  (*! *****************************************************************************
  Copyright (C) Microsoft. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0
  
  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.
  
  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  ***************************************************************************** *)
*/