// Module ID: 1257
// Function ID: 14137
// Name: createExporter
// Dependencies: []

// Module 1257 (createExporter)
const global = arg0;
const dependencyMap = arg4;
(function(arg0) {
  let _self = this;
  let closure_0 = arg0;
  function createExporter(_self, exporter) {
    let closure_0 = _self;
    let closure_1 = exporter;
    if (_self !== closure_1) {
      const _Object = Object;
      if ("function" === typeof Object.create) {
        const _Object2 = Object;
        const obj = { value: true };
      } else {
        _self.__esModule = true;
      }
    }
    return (arg0, arg1) => {
      let tmp2 = arg1;
      if (exporter) {
        tmp2 = exporter(arg0, arg1);
      }
      closure_0[arg0] = tmp2;
      return tmp2;
    };
  }
  if ("object" === typeof closure_0) {
    _self = closure_0;
  } else {
    _self = self;
    if ("object" === typeof self) {
      _self = self;
    } else if ("object" !== typeof _self) {
      _self = {};
    }
  }
  if ("function" === typeof globalThis.define) {
    if (globalThis.define.amd) {
      globalThis.define("tslib", ["exports"], (_self) => {
        callback(createExporter(_self, createExporter(_self)));
      });
    }
  }
  if ("object" === typeof _self) {
    if ("object" === typeof _self.exports) {
      arg0(createExporter(_self, createExporter(_self.exports)));
    }
  }
  arg0(createExporter(_self));
})((arg0) => {
  let fn = Object.setPrototypeOf;
  if (!fn) {
    let _Array = Array;
    fn = Object.create([]) instanceof Array && ((arg0, arg1) => {
      arg0.__proto__ = arg1;
    });
    let tmp = Object.create([]) instanceof Array && ((arg0, arg1) => {
      arg0.__proto__ = arg1;
    });
  }
  if (!fn) {
    fn = (arg0, obj) => {
      for (const key10005 in arg1) {
        let tmp = key10005;
        let _Object = Object;
        if (!hasOwnProperty.call(arg1, key10005)) {
          continue;
        } else {
          arg0[key10005] = arg1[key10005];
          continue;
        }
        continue;
      }
    };
  }
  let ownKeys = function __extends(arg0, Error) {
    const lib = arg0;
    function __(tmpResult, arg1) {
      this.constructor = closure_0;
    }
    if ("function" !== typeof Error) {
      if (null !== Error) {
        const _TypeError = TypeError;
        const _String = String;
        const typeError = new TypeError("Class extends value " + String(Error) + " is not a constructor or null");
        throw typeError;
      }
    }
    lib(arg0, Error);
    if (null === Error) {
      const _Object = Object;
      __ = Object.create(Error);
    } else {
      __.prototype = Error.prototype;
      const prototype = __.prototype;
      __ = new __();
    }
    arg0.prototype = __;
  };
  let closure_3 = Object.assign || ((arg0) => {
    for (let num = 1; num < length; num = num + 1) {
      let tmp3 = arguments[num];
      let tmp4 = tmp3;
      let tmp5 = tmp2;
      let keys = Object.keys();
      if (keys !== undefined) {
        tmp2 = tmp5;
        let tmp7 = keys[tmp];
        while (tmp7 !== undefined) {
          let tmp8 = tmp7;
          let _Object = Object;
          tmp5 = tmp7;
          if (!hasOwnProperty.call(tmp3, tmp7)) {
            continue;
          } else {
            arg0[tmp7] = tmp3[tmp7];
            tmp5 = tmp7;
            continue;
          }
          continue;
        }
      }
    }
    return arg0;
  });
  function __rest(obj, arr) {
    obj = {};
    for (const key10007 in arg0) {
      let tmp3 = key10007;
      let _Object3 = Object;
      let callResult = hasOwnProperty.call(arg0, key10007);
      if (callResult) {
        callResult = arg1.indexOf(key10007) < 0;
      }
      if (!callResult) {
        continue;
      } else {
        obj[key10007] = arg0[key10007];
        continue;
      }
      continue;
    }
    if (null != obj) {
      const _Object4 = Object;
      if ("function" === typeof Object.getOwnPropertySymbols) {
        const _Object = Object;
        const ownPropertySymbols = Object.getOwnPropertySymbols(obj);
        for (let num = 0; num < ownPropertySymbols.length; num = num + 1) {
          let callResult1 = arr.indexOf(ownPropertySymbols[num]) < 0;
          if (callResult1) {
            let _Object2 = Object;
            callResult1 = propertyIsEnumerable.call(obj, ownPropertySymbols[num]);
          }
          if (callResult1) {
            obj[ownPropertySymbols[num]] = obj[ownPropertySymbols[num]];
          }
        }
      }
    }
    return obj;
  }
  function __decorate(arg0, arg1, arg2, arg3) {
    const length = arguments.length;
    let tmp = arg3;
    let tmp2 = arg1;
    if (length >= 3) {
      let ownPropertyDescriptor = arg3;
      let tmp5 = arg3;
      if (null === arg3) {
        const _Object = Object;
        ownPropertyDescriptor = Object.getOwnPropertyDescriptor(arg1, arg2);
        tmp5 = ownPropertyDescriptor;
      }
      tmp = ownPropertyDescriptor;
      tmp2 = tmp5;
    }
    if ("object" === typeof Reflect) {
      const _Reflect = Reflect;
      if ("function" === typeof Reflect.decorate) {
        const _Reflect2 = Reflect;
        const _Reflect3 = Reflect;
        let decorateResult = Reflect.decorate(arg0, arg1, arg2, tmp);
      }
      if (tmp17) {
        const _Object2 = Object;
        Object.defineProperty(arg1, arg2, decorateResult);
      }
      return decorateResult;
    }
    let diff = arg0.length - 1;
    let tmp8 = tmp2;
    decorateResult = tmp2;
    if (diff >= 0) {
      do {
        let tmp10 = arg0[diff];
        let tmp11 = tmp8;
        if (tmp10) {
          if (length < 3) {
            let tmp10Result = tmp10(tmp8);
          } else {
            tmp10Result = length > 3 ? tmp10(arg1, arg2, tmp8) : tmp10(arg1, arg2);
          }
          if (!tmp10Result) {
            tmp10Result = tmp8;
          }
          tmp11 = tmp10Result;
        }
        diff = diff - 1;
        tmp8 = tmp11;
        decorateResult = tmp11;
      } while (diff >= 0);
    }
  }
  function __param(arg0, arg1) {
    let closure_0 = arg0;
    let closure_1 = arg1;
    return (arg0, arg1) => {
      callback(arg0, arg1, closure_0);
    };
  }
  function __esDecorate(arg0, arg1, arg2, kind, arr) {
    let set;
    let closure_0 = arg5;
    function accept(comma, arg1) {
      if (undefined !== comma) {
        if ("function" !== typeof comma) {
          const _TypeError = TypeError;
          const typeError = new TypeError("Function expected");
          throw typeError;
        }
      }
      return comma;
    }
    kind = kind.kind;
    let str = "get";
    if ("getter" !== kind) {
      let str2 = "value";
      if ("setter" === kind) {
        str2 = "set";
      }
      str = str2;
    }
    let tmp = null;
    if (!arg1) {
      tmp = null;
      if (arg0) {
        let prototype = arg0;
        if (!kind.static) {
          prototype = arg0.prototype;
        }
        tmp = prototype;
      }
    }
    if (arg1) {
      let c1 = false;
      let diff = arg2.length - 1;
      if (diff >= 0) {
        while (true) {
          let obj = {};
          let tmp8 = kind;
          let tmp9 = tmp7;
          let tmp10 = tmp7;
          let keys = Object.keys();
          if (keys !== undefined) {
            tmp10 = tmp9;
            let tmp12 = keys[set];
            while (tmp12 !== undefined) {
              tmp9 = tmp12;
              obj[tmp9] = "access" === tmp12 ? {} : kind[tmp9];
              continue;
            }
          }
          let tmp13 = tmp10;
          tmp7 = tmp10;
          let keys1 = Object.keys();
          if (keys1 !== undefined) {
            tmp7 = tmp13;
            let tmp15 = keys1[set];
            while (tmp15 !== undefined) {
              tmp13 = tmp15;
              obj.access[tmp15] = kind.access[tmp15];
              continue;
            }
          }
          obj.addInitializer = (arg0) => {
            let tmp = arg0;
            if (c1) {
              const _TypeError = TypeError;
              const typeError = new TypeError("Cannot add initializers after decoration has completed");
              throw typeError;
            } else {
              if (!tmp) {
                tmp = null;
              }
              accept(tmp);
              arr = arr.push(tmp);
            }
          };
          if (tmp5) {
            obj = {};
            ({ get: obj3.get, set } = arg1);
            obj.set = set;
            let tmp16 = obj;
          } else {
            tmp16 = arg1[str];
          }
          let tmp17 = arg2[diff](tmp16, obj);
          if (tmp5) {
            let tmp19 = tmp6;
            if (undefined !== tmp17) {
              if (null === tmp17) {
                break;
              } else if ("object" !== typeof tmp17) {
                break;
              } else {
                let get = tmp17.get;
                let acceptResult = accept(get);
                if (get) {
                  arg1.get = get;
                }
                let set2 = tmp17.set;
                let acceptResult1 = accept(set2);
                if (set2) {
                  arg1.set = set2;
                }
                let init = tmp17.init;
                let acceptResult2 = accept(init);
                tmp19 = init;
                if (init) {
                  arr = arr.unshift(init);
                  tmp19 = init;
                }
              }
            }
          } else {
            let acceptResult3 = accept(tmp17);
            tmp19 = tmp17;
            if (tmp17) {
              if ("field" === kind) {
                arr = arr.unshift(tmp17);
                tmp19 = tmp17;
              } else {
                arg1[str] = tmp17;
                tmp19 = tmp17;
              }
            }
          }
          diff = diff - 1;
          tmp6 = tmp19;
        }
        let _TypeError = TypeError;
        let typeError = new TypeError("Object expected");
        throw typeError;
      }
      if (tmp) {
        const _Object2 = Object;
        Object.defineProperty(tmp, kind.name, arg1);
      }
      c1 = true;
    } else if (tmp) {
      const _Object = Object;
      let ownPropertyDescriptor = Object.getOwnPropertyDescriptor(tmp, kind.name);
    } else {
      ownPropertyDescriptor = {};
    }
  }
  function __runInitializers(arg0, arg1, arg2) {
    let tmp = arg2;
    const tmp2 = arguments.length > 2;
    let num = 0;
    let tmp3 = arg2;
    if (0 < arg1.length) {
      do {
        let tmp4 = arg1[num];
        let call = tmp4.call;
        let tmp5 = tmp2 ? call(arg0, tmp) : call(arg0);
        num = num + 1;
        tmp = tmp5;
        tmp3 = tmp5;
      } while (num < arg1.length);
    }
    let tmp6;
    if (tmp2) {
      tmp6 = tmp3;
    }
    return tmp6;
  }
  function __propKey(arg0) {
    let combined = arg0;
    if ("symbol" !== typeof arg0) {
      const concat = "".concat;
      combined = "".concat(arg0);
    }
    return combined;
  }
  function __setFunctionName(arg0, description) {
    let tmp = description;
    if ("symbol" === typeof description) {
      let str = "";
      if (description.description) {
        const concat = "[".concat;
        str = "[".concat(description.description, "]");
      }
      tmp = str;
    }
    const obj = { configurable: true };
    let combined = tmp;
    if (arg2) {
      const concat2 = "".concat;
      combined = "".concat(arg2, " ", tmp);
    }
    obj.value = combined;
    return Object.defineProperty(arg0, "name", obj);
  }
  function __metadata(arg0, arg1) {
    if ("object" === typeof Reflect) {
      const _Reflect = Reflect;
      if ("function" === typeof Reflect.metadata) {
        const _Reflect2 = Reflect;
        return Reflect.metadata(arg0, arg1);
      }
    }
  }
  function __awaiter(arg0, arg1, arg2, arg3) {
    let _Promise = arg2;
    let closure_0 = arg0;
    let closure_1 = arg1;
    let closure_3 = arg3;
    if (!arg2) {
      _Promise = Promise;
    }
    _Promise = new _Promise((arg0, arg1) => {
      let closure_0 = arg0;
      let closure_1 = arg1;
      function fulfilled(arg0) {
        step(iter.next(arg0));
      }
      let iter = function rejected(arg0) {
        step(iter.throw(arg0));
      };
      function step(iter) {
        if (iter.done) {
          callback(iter.value);
        } else {
          (function adopt(value) {
            let tmp = value;
            let closure_0 = value;
            if (!(value instanceof fulfilled)) {
              const prototype = fulfilled.prototype;
              tmp = new fulfilled(() => { ... });
            }
            return tmp;
          })(iter.value).then(fulfilled, iter);
          const promise = (function adopt(value) {
            let tmp = value;
            let closure_0 = value;
            if (!(value instanceof fulfilled)) {
              const prototype = fulfilled.prototype;
              tmp = new fulfilled(() => { ... });
            }
            return tmp;
          })(iter.value);
        }
      }
      let items = closure_1;
      if (!closure_1) {
        items = [];
      }
      iter = iter.apply(closure_0, items);
      step(iter.next());
    });
    return _Promise;
  }
  function __generator(arg0, arg1) {
    let closure_0 = arg0;
    let closure_1 = arg1;
    function verb(arg0) {
      let closure_0 = arg0;
      return (arg0) => {
        const items = [closure_0, arg0];
        let items2 = items;
        if (outer1_2) {
          const _TypeError = TypeError;
          const typeError = new TypeError("Generator is already executing.");
          throw typeError;
        } else {
          if (outer1_6) {
            outer1_6 = 0;
            if (items2[0]) {
              let outer1_5 = 0;
            }
          }
          if (!outer1_5) {
            if (5 & items2[0]) {
              throw items2[1];
            } else {
              let obj = {};
              let tmp70;
              if (items2[0]) {
                tmp70 = items2[1];
              }
              obj.value = tmp70;
              obj.done = true;
              let tmp15 = obj;
            }
          } else {
            while (true) {
              outer1_2 = 1;
              let tmp4 = outer1_3;
              if (outer1_3) {
                let tmp5 = items2;
                if (2 & items2[0]) {
                  let tmp11 = outer1_3;
                  let next = outer1_3.return;
                } else {
                  let tmp6 = items2;
                  let iter = outer1_3;
                  if (items2[0]) {
                    let _throw = iter.throw;
                    let num10 = _throw;
                    if (!_throw) {
                      let tmp7 = outer1_3;
                      let _return = outer1_3.return;
                      let outer1_4 = _return;
                      if (_return) {
                        let tmp8 = outer1_4;
                        let tmp9 = outer1_3;
                        let callResult = outer1_4.call(outer1_3);
                      }
                      num10 = 0;
                    }
                    next = num10;
                  } else {
                    next = iter.next;
                  }
                }
                outer1_4 = next;
                if (next) {
                  let tmp12 = outer1_4;
                  let tmp13 = outer1_3;
                  let tmp14 = items2;
                  let iter2 = outer1_4.call(outer1_3, items2[1]);
                  outer1_4 = iter2;
                  if (!iter2.done) {
                    break;
                  }
                }
              }
              outer1_3 = 0;
              let tmp16 = outer1_4;
              if (outer1_4) {
                let tmp17 = items2;
                let items1 = [2 & items2[0], ];
                let tmp18 = outer1_4;
                items1[1] = outer1_4.value;
                items2 = items1;
              }
              let tmp19 = items2;
              let first = items2[0];
              if (0 !== first) {
                if (1 !== first) {
                  if (4 === first) {
                    let tmp57 = outer1_5;
                    outer1_5.label = outer1_5.label + 1;
                    obj = {};
                    let tmp58 = items2;
                    obj.value = items2[1];
                    let flag = false;
                    obj.done = false;
                    outer1_4 = 0;
                    outer1_2 = 0;
                    tmp15 = obj;
                  } else {
                    if (5 === first) {
                      let tmp55 = outer1_5;
                      outer1_5.label = outer1_5.label + 1;
                      let tmp56 = items2;
                      outer1_3 = items2[1];
                      items2 = [0];
                      outer1_4 = 0;
                      outer1_2 = 0;
                    } else if (7 === first) {
                      let tmp52 = outer1_5;
                      let ops = outer1_5.ops;
                      items2 = ops.pop();
                      let tmp53 = outer1_5;
                      let trys = outer1_5.trys;
                      let arr = trys.pop();
                      outer1_4 = 0;
                      outer1_2 = 0;
                    } else {
                      let tmp76 = outer1_5;
                      let trys1 = outer1_5.trys;
                      outer1_4 = trys1;
                      let tmp77 = trys1.length > 0;
                      let tmp22 = tmp77;
                      if (tmp77) {
                        let tmp21 = outer1_4;
                        tmp22 = outer1_4[outer1_4.length - 1];
                      }
                      outer1_4 = tmp22;
                      if (tmp22) {
                        let tmp25 = items2;
                        if (3 !== items2[0]) {
                          let tmp31 = items2;
                          if (6 === items2[0]) {
                            let tmp32 = outer1_5;
                            let tmp33 = outer1_4;
                            if (outer1_5.label < outer1_4[1]) {
                              let tmp47 = outer1_5;
                              let tmp48 = outer1_4;
                              outer1_5.label = outer1_4[1];
                              let tmp49 = items2;
                              outer1_4 = items2;
                            }
                          }
                          let tmp34 = outer1_4;
                          if (outer1_4) {
                            let tmp35 = outer1_5;
                            let tmp36 = outer1_4;
                            if (outer1_5.label < outer1_4[2]) {
                              let tmp42 = outer1_5;
                              let tmp43 = outer1_4;
                              outer1_5.label = outer1_4[2];
                              let tmp44 = outer1_5;
                              let ops1 = outer1_5.ops;
                              let tmp45 = items2;
                              arr = ops1.push(items2);
                            }
                          }
                          let tmp37 = outer1_4;
                          if (outer1_4[2]) {
                            let tmp38 = outer1_5;
                            let ops2 = outer1_5.ops;
                            let arr1 = ops2.pop();
                          }
                          let tmp40 = outer1_5;
                          let trys2 = outer1_5.trys;
                          let arr2 = trys2.pop();
                          outer1_4 = 0;
                          outer1_2 = 0;
                        } else {
                          let tmp26 = outer1_4;
                          if (outer1_4) {
                            let tmp27 = items2;
                            let tmp28 = outer1_4;
                            if (items2[1] > outer1_4[0]) {
                              let tmp29 = items2;
                              let tmp30 = outer1_4;
                            }
                          }
                          let tmp50 = outer1_5;
                          let tmp51 = items2;
                          outer1_5.label = items2[1];
                        }
                        let tmp60 = outer1_1;
                        let tmp61 = closure_0;
                        let tmp62 = outer1_5;
                        let callResult1 = outer1_1.call(closure_0, outer1_5);
                        outer1_4 = 0;
                        outer1_2 = 0;
                        while (true) {
                          let items3 = [6, __exception];
                          let tmp64 = items3;
                          outer1_3 = 0;
                          continue;
                        }
                      } else {
                        let tmp23 = items2;
                        if (6 === items2[0]) {
                          outer1_5 = 0;
                          outer1_4 = 0;
                          outer1_2 = 0;
                        } else {
                          let tmp24 = items2;
                        }
                      }
                    }
                    let tmp65 = outer1_6;
                    if (outer1_6) {
                      outer1_6 = 0;
                      let tmp66 = items2;
                      if (items2[0]) {
                        outer1_5 = 0;
                      }
                    }
                    let tmp67 = outer1_5;
                  }
                }
              }
              let tmp59 = items2;
              outer1_4 = items2;
            }
            tmp15 = outer1_4;
            outer1_4 = 0;
            outer1_2 = 0;
          }
          return tmp15;
        }
      };
    }
    let obj = {
      label: 0,
      sent() {
        if (1 & dependencyMap[0]) {
          throw tmp;
        } else {
          return tmp;
        }
      },
      trys: [],
      ops: []
    };
    obj = Object.create("function" === typeof globalThis.Iterator ? globalThis.Iterator : Object.prototype);
    obj.next = verb(0);
    obj.throw = verb(1);
    obj.return = verb(2);
    if ("function" === typeof Symbol) {
      const _Symbol = Symbol;
      obj[Symbol.iterator] = function() {
        return this;
      };
    }
    return obj;
  }
  function __exportStar(obj, exports) {
    for (const key10007 in arg0) {
      let tmp4 = key10007;
      let callResult = "default" === key10007;
      if (!callResult) {
        let _Object = Object;
        callResult = hasOwnProperty.call(arg1, key10007);
      }
      if (callResult) {
        continue;
      } else {
        let tmp2 = callback2;
        let tmp3 = callback2(arg1, arg0, key10007);
        continue;
      }
      continue;
    }
  }
  let closure_30 = Object.create ? ((arg0, arg1, arg2, arg3) => {
    let __esModule = arg1;
    let tmp = arg3;
    let closure_0 = arg1;
    let closure_1 = arg2;
    if (undefined === arg3) {
      tmp = arg2;
    }
    let ownPropertyDescriptor = Object.getOwnPropertyDescriptor(__esModule, arg2);
    if (!ownPropertyDescriptor) {
      if (!ownPropertyDescriptor) {
        const obj = {
          enumerable: true,
          get() {
                return table[closure_1];
              }
        };
        ownPropertyDescriptor = obj;
      }
      const _Object = Object;
      Object.defineProperty(arg0, tmp, ownPropertyDescriptor);
    } else if ("get" in ownPropertyDescriptor) {
      __esModule = __esModule.__esModule;
      let tmp3 = !__esModule;
    } else {
      tmp3 = ownPropertyDescriptor.writable || ownPropertyDescriptor.configurable;
    }
  }) : ((arg0, arg1, arg2, arg3) => {
    let tmp = arg3;
    if (undefined === arg3) {
      tmp = arg2;
    }
    arg0[tmp] = arg1[arg2];
  });
  function __values(arg0) {
    const lib = arg0;
    let iterator = "function" === typeof Symbol;
    if (iterator) {
      const _Symbol = Symbol;
      iterator = Symbol.iterator;
    }
    let obj = iterator;
    if (iterator) {
      obj = lib[iterator];
    }
    let c1 = 0;
    if (obj) {
      return obj.call(lib);
    } else {
      if (lib) {
        if ("number" === typeof lib.length) {
          obj = {
            next() {
                    let tmp = length;
                    if (length) {
                      tmp = closure_1 >= length.length;
                    }
                    const obj = {};
                    let tmp4 = length;
                    if (length) {
                      closure_1 = tmp7 + 1;
                      tmp4 = length[tmp7];
                    }
                    obj.value = tmp4;
                    obj.done = !length;
                    return obj;
                  }
          };
          return obj;
        }
      }
      let _TypeError = TypeError;
      let str2 = "Symbol.iterator is not defined.";
      if (iterator) {
        str2 = "Object is not iterable.";
      }
      const prototype = _TypeError.prototype;
      _TypeError = new _TypeError(str2);
      throw _TypeError;
    }
  }
  function __read(arg0) {
    let diff = arg1;
    let tmp3 = "function" === typeof Symbol;
    if (tmp3) {
      const _Symbol = Symbol;
      tmp3 = arg0[Symbol.iterator];
    }
    let obj = tmp3;
    if (tmp3) {
      const iter2 = obj.call(arg0);
      const items = [];
      if (undefined === diff) {
        const iter3 = iter2.next();
        let iter = iter3;
        if (!iter3.done) {
          while (true) {
            let tmp11 = items;
            let tmp12 = iter;
            let arr = items.push(iter.value);
            let tmp14 = diff;
            if (undefined === diff) {
              let tmp17 = iter2;
              let iter4 = iter2.next();
              iter = iter4;
              if (iter4.done) {
                break;
              }
            } else {
              let tmp15 = diff;
              let tmp16 = +diff;
              diff = tmp16 - 1;
              if (tmp16 <= 0) {
                break;
              }
            }
            break;
          }
        }
      } else {
        diff = tmp9 - 1;
      }
      while (true) {
        let tmp18 = iter;
        let tmp19 = iter;
        if (!iter) {
          break;
        } else {
          let tmp20 = iter;
          tmp19 = !iter.done;
          break;
        }
        let tmp21 = tmp19;
        if (tmp19) {
          let tmp22 = iter2;
          let _return = iter2.return;
          obj = _return;
          tmp21 = _return;
        }
        if (tmp21) {
          let tmp23 = obj;
          let tmp24 = iter2;
          let callResult = obj.call(iter2);
        }
        let tmp26 = tmp2;
        if (tmp2) {
          let tmp27 = tmp2;
          throw tmp2.error;
        } else {
          return items;
        }
      }
    } else {
      return arg0;
    }
  }
  function __spread() {
    let length;
    let items = [];
    let num = 0;
    let tmp = items;
    if (0 < arguments.length) {
      do {
        let tmp2 = __read;
        items = items.concat(__read(arguments[num]));
        num = num + 1;
        tmp = items;
        length = arguments.length;
      } while (num < length);
    }
    return tmp;
  }
  function __spreadArrays() {
    const length = arguments.length;
    let num = 0;
    let num2 = 0;
    let num3 = 0;
    if (0 < length) {
      do {
        num = num + arguments[num2].length;
        num2 = num2 + 1;
        num3 = num;
      } while (num2 < length);
    }
    const ArrayResult = Array(num3);
    let num4 = 0;
    let num5 = 0;
    if (0 < length) {
      do {
        let arr = arguments[num4];
        let length2 = arr.length;
        let sum = num5;
        let num6 = 0;
        if (0 < length2) {
          do {
            ArrayResult[sum] = arr[num6];
            num6 = num6 + 1;
            sum = sum + 1;
            num5 = sum;
          } while (num6 < length2);
        }
        num4 = num4 + 1;
      } while (num4 < length);
    }
    return ArrayResult;
  }
  function __spreadArray(items1, items, arg2) {
    if (arg2) {
      let num3 = 0;
      if (0 < items.length) {
        do {
          let tmp4 = !tmp3 && num3 in items;
          let tmp5 = tmp3;
          if (!tmp4) {
            let callResult = tmp3;
            if (!tmp3) {
              let _Array = Array;
              callResult = slice.call(items, 0, num3);
            }
            callResult[num3] = items[num3];
            tmp5 = callResult;
          }
          num3 = num3 + 1;
          tmp3 = tmp5;
          let callResult1 = tmp5;
        } while (num3 < length);
      }
    }
    if (!callResult1) {
      const _Array2 = Array;
      callResult1 = slice2.call(items);
    }
    return items1.concat(callResult1);
  }
  function __await(closure_0) {
    const self = this;
    if (this instanceof __await) {
      self.v = closure_0;
      let tmp5 = self;
    } else {
      const prototype = __await.prototype;
      tmp5 = new __await(closure_0);
    }
    return tmp5;
  }
  function __asyncGenerator(arg0, arg1, apply) {
    let items = arg1;
    function verb(next, arg1) {
      if (dependencyMap[next]) {
        obj[next] = (arg0) => {
          let closure_0 = arg0;
          return new Promise((arg0, arg1) => {
            const items = [closure_0, closure_0, arg0, arg1];
            if (outer2_2.push(items) <= 1) {
              outer2_3(closure_0, closure_0);
            }
          });
        };
        if (arg1) {
          obj[next] = arg1(obj[next]);
        }
      }
    }
    function resume(arg0, arg1) {
      const iter = dependencyMap[arg0](arg1);
      if (iter.value instanceof __await) {
        const resolved = Promise.resolve(iter.value.v);
        resolved.then(fulfill, reject);
      } else {
        settle(arr[0][2], iter);
      }
    }
    function fulfill(arg0) {
      resume("next", arg0);
    }
    function reject(arg0) {
      resume("throw", arg0);
    }
    function settle(arg0, arg1) {
      arg0(arg1);
      arr = arr.shift();
      if (arr.length) {
        resume(arr[0][0], arr[0][1]);
      }
    }
    if (Symbol.asyncIterator) {
      if (!items) {
        items = [];
      }
      let closure_1 = apply.apply(arg0, items);
      let closure_2 = [];
      const obj = Object.create("function" === typeof globalThis.AsyncIterator ? globalThis.AsyncIterator : Object.prototype);
      verb("next");
      verb("throw");
      verb("return", function awaitReturn(arg0) {
        let closure_0 = arg0;
        return (arg0) => {
          const resolved = Promise.resolve(arg0);
          return resolved.then(closure_0, outer1_5);
        };
      });
      const _Symbol = Symbol;
      obj[Symbol.asyncIterator] = function() {
        return this;
      };
      return obj;
    } else {
      const _TypeError = TypeError;
      const typeError = new TypeError("Symbol.asyncIterator is not defined.");
      throw typeError;
    }
  }
  function __asyncDelegator(arg0) {
    let closure_0 = arg0;
    function verb(next, arg1) {
      let fn = arg1;
      const table = next;
      let closure_1 = arg1;
      if (table[next]) {
        fn = (arg0) => {
          outer1_2 = !outer1_2;
          if (outer1_2) {
            let tmp5 = arg0;
            if (callback) {
              tmp5 = callback(arg0);
            }
            let obj = tmp5;
          } else {
            obj = { value: __await(next[next](arg0)), done: false };
          }
          return obj;
        };
      }
      closure_1[next] = fn;
    }
    let obj = {};
    verb("next");
    verb("throw", (arg0) => {
      throw arg0;
    });
    verb("return");
    obj[Symbol.iterator] = function() {
      return this;
    };
    return obj;
  }
  function __asyncValues(arg0) {
    let closure_0 = arg0;
    function verb(next) {
      const table = next;
      let fn = table[next];
      if (fn) {
        fn = (arg0) => {
          let closure_0 = arg0;
          return new Promise((arg0, arg1) => {
            iter = dependencyMap[dependencyMap](iter);
            (function settle() { ... })(arg0, arg1, iter.done, iter.value);
          });
        };
      }
      closure_1[next] = fn;
    }
    if (Symbol.asyncIterator) {
      const _Symbol = Symbol;
      if (arg0[Symbol.asyncIterator]) {
        let callResult = obj.call(arg0);
      } else {
        closure_0 = __values(arg0);
        callResult = {};
        let closure_1 = callResult;
        verb("next");
        verb("throw");
        verb("return");
        const _Symbol2 = Symbol;
        callResult[Symbol.asyncIterator] = function() {
          return this;
        };
      }
      return callResult;
    } else {
      const _TypeError = TypeError;
      const typeError = new TypeError("Symbol.asyncIterator is not defined.");
      throw typeError;
    }
  }
  function __makeTemplateObject(arg0, value) {
    if (Object.defineProperty) {
      const _Object = Object;
      const obj = { value };
      Object.defineProperty(arg0, "raw", obj);
    } else {
      arg0.raw = value;
    }
    return arg0;
  }
  let closure_1 = Object.create ? ((arg0, value) => {
    Object.defineProperty(arg0, "default", { enumerable: true, value });
  }) : ((arg0, arg1) => {
    arg0.default = arg1;
  });
  ownKeys = function ownKeys(arg0) {
    let tmp = Object.getOwnPropertyNames || ((obj) => {
      const items = [];
      for (const key10005 in arg0) {
        let tmp = key10005;
        let _Object = Object;
        if (!hasOwnProperty.call(arg0, key10005)) {
          continue;
        } else {
          items[items.length] = key10005;
          continue;
        }
        continue;
      }
      return items;
    });
    const ownKeys = tmp;
    return tmp(arg0);
  };
  function __importStar(__esModule) {
    if (__esModule) {
      if (__esModule.__esModule) {
        return __esModule;
      }
    }
    const obj = {};
    if (null != __esModule) {
      const arr = ownKeys(__esModule);
      for (let num = 0; num < arr.length; num = num + 1) {
        if ("default" !== arr[num]) {
          let tmp2 = callback2;
          let tmp3 = callback2(obj, __esModule, arr[num]);
        }
      }
    }
    callback(obj, __esModule);
    return obj;
  }
  function __importDefault(__esModule) {
    if (!__esModule) {
      const obj = { default: __esModule };
      let tmp = obj;
    } else {
      tmp = __esModule;
    }
    return tmp;
  }
  function __classPrivateFieldGet(arg0, has, arg2, call) {
    if ("a" === arg2) {
      if (!call) {
        const _TypeError = TypeError;
        const typeError = new TypeError("Private accessor was defined without a getter");
        throw typeError;
      }
    }
    if ("function" === typeof has) {
      let tmp7 = arg0 !== has || !call;
      const tmp8 = arg0 !== has || !call;
    } else {
      tmp7 = !has.has(arg0);
    }
    if (tmp7) {
      const _TypeError2 = TypeError;
      const typeError1 = new TypeError("Cannot read private member from an object whose class did not declare it");
      throw typeError1;
    } else if ("m" === arg2) {
      return call;
    } else if (tmp) {
      let callResult = call.call(arg0);
    } else if (call) {
      callResult = call.value;
    } else {
      callResult = has.get(arg0);
    }
  }
  function __classPrivateFieldSet(arg0, has, value, arg3, call) {
    if ("m" === arg3) {
      const _TypeError3 = TypeError;
      const typeError = new TypeError("Private method is not writable");
      throw typeError;
    } else {
      if ("a" === arg3) {
        if (!call) {
          const _TypeError = TypeError;
          const typeError1 = new TypeError("Private accessor was defined without a setter");
          throw typeError1;
        }
      }
      if ("function" === typeof has) {
        let tmp6 = arg0 !== has || !call;
        const tmp7 = arg0 !== has || !call;
      } else {
        tmp6 = !has.has(arg0);
      }
      if (tmp6) {
        const _TypeError2 = TypeError;
        const typeError2 = new TypeError("Cannot write private member to an object whose class did not declare it");
        throw typeError2;
      } else {
        if (tmp20) {
          call.call(arg0, value);
        } else if (call) {
          call.value = value;
        } else {
          const result = has.set(arg0, value);
        }
        return value;
      }
    }
  }
  function __classPrivateFieldIn(has) {
    if (null !== arg1) {
      if ("function" === typeof has) {
        let hasItem = arg1 === has;
      } else {
        hasItem = has.has(arg1);
      }
      return hasItem;
    }
    const typeError = new TypeError("Cannot use 'in' operator on non-object");
    throw typeError;
  }
  function __addDisposableResource(stack, value, arg2) {
    if (null != value) {
      if ("object" !== typeof value) {
        if ("function" !== tmp2) {
          const _TypeError4 = TypeError;
          const typeError = new TypeError("Object expected.");
          throw typeError;
        }
      }
      let dispose;
      if (arg2) {
        const _Symbol = Symbol;
        if (Symbol.asyncDispose) {
          const _Symbol2 = Symbol;
          dispose = value[Symbol.asyncDispose];
        } else {
          const _TypeError = TypeError;
          const typeError1 = new TypeError("Symbol.asyncDispose is not defined.");
          throw typeError1;
        }
      }
      if (undefined === dispose) {
        const _Symbol3 = Symbol;
        if (Symbol.dispose) {
          const _Symbol4 = Symbol;
          dispose = tmp14;
          if (arg2) {
            dispose = tmp14;
            const tmp8 = tmp14;
          }
        } else {
          const _TypeError2 = TypeError;
          const typeError2 = new TypeError("Symbol.dispose is not defined.");
          throw typeError2;
        }
      }
      if ("function" !== typeof dispose) {
        const _TypeError3 = TypeError;
        const typeError3 = new TypeError("Object not disposable.");
        throw typeError3;
      } else {
        if (tmp8) {
          dispose = function dispose() {
            tmp14.call(this);
          };
        }
        stack = stack.stack;
        let obj = { value, dispose, async: arg2 };
        stack.push(obj);
      }
    } else if (arg2) {
      const stack1 = stack.stack;
      obj = { async: true };
      stack1.push(obj);
    }
    return value;
  }
  closure_3 = "function" === typeof globalThis.SuppressedError ? globalThis.SuppressedError : ((error, suppressed) => {
    error = new Error(arg2);
    error.name = "SuppressedError";
    error.error = error;
    error.suppressed = suppressed;
    return error;
  });
  function __disposeResources(arg0) {
    let closure_0 = arg0;
    function fail(reconnect, error, arg2) {
      let tmp2 = reconnect;
      if (closure_0.hasError) {
        const prototype = fail.prototype;
        tmp2 = new fail(reconnect, closure_0.error, "An error was suppressed during disposal.");
      }
      closure_0.error = tmp2;
      closure_0.hasError = true;
    }
    let c2 = 0;
    function next() {
      const stack = closure_0.stack;
      let arr = stack.pop();
      if (arr) {
        while (true) {
          let tmp2 = arr;
          if (!arr.async) {
            let tmp3 = c2;
            if (1 === c2) {
              break;
            }
          }
          let tmp9 = arr;
          if (arr.dispose) {
            let tmp11 = arr;
            let dispose = arr.dispose;
            let tmp12 = arr;
            let callResult = dispose.call(arr.value);
            let tmp14 = arr;
            if (arr.async) {
              let tmp15 = c2;
              let num2 = 2;
              c2 = c2 | 2;
              let tmp16 = globalThis;
              let _Promise2 = Promise;
              let tmp17 = callResult;
              let resolved = Promise.resolve(callResult);
              let tmp18 = next;
              return resolved.then(next, (arg0) => {
                outer1_3(arg0);
                return outer1_4();
              });
            }
          } else {
            let tmp10 = c2;
            c2 = c2 | 1;
          }
          do {
            let tmp19 = closure_0;
            let stack1 = closure_0.stack;
            arr = stack1.pop();
          } while (!arr);
        }
        c2 = 0;
        const stack2 = closure_0.stack;
        stack2.push(arr);
        const resolved1 = Promise.resolve();
        return resolved1.then(next);
      }
      if (1 === c2) {
        if (closure_0.hasError) {
          let rejectResult = _Promise3.reject(closure_0.error);
        } else {
          rejectResult = _Promise3.resolve();
        }
        return rejectResult;
      } else if (closure_0.hasError) {
        throw closure_0.error;
      }
    }
    return next();
  }
  function __rewriteRelativeImportExtension(str) {
    let closure_0 = arg1;
    let replaced = str;
    if ("string" === typeof str) {
      replaced = str;
      if (obj.test(str)) {
        replaced = str.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, (arg0, arg1, arg2, arg3, arg4) => {
          if (arg1) {
            let str3 = ".js";
            if (closure_0) {
              str3 = ".jsx";
            }
            let text = str3;
          } else if (!arg2) {
            const sum = arg2 + arg3;
            text = `${tmp2 + "." + arg4.toLowerCase()}js`;
          } else {
            text = arg0;
            if (arg3) {
              text = arg0;
            }
          }
          return text;
        });
      }
      obj = /^\.\.?\//;
    }
    return replaced;
  }
  arg0("__extends", ownKeys);
  arg0("__assign", closure_3);
  arg0("__rest", __rest);
  arg0("__decorate", __decorate);
  arg0("__param", __param);
  arg0("__esDecorate", __esDecorate);
  arg0("__runInitializers", __runInitializers);
  arg0("__propKey", __propKey);
  arg0("__setFunctionName", __setFunctionName);
  arg0("__metadata", __metadata);
  arg0("__awaiter", __awaiter);
  arg0("__generator", __generator);
  arg0("__exportStar", __exportStar);
  arg0("__createBinding", closure_30);
  arg0("__values", __values);
  arg0("__read", __read);
  arg0("__spread", __spread);
  arg0("__spreadArrays", __spreadArrays);
  arg0("__spreadArray", __spreadArray);
  arg0("__await", __await);
  arg0("__asyncGenerator", __asyncGenerator);
  arg0("__asyncDelegator", __asyncDelegator);
  arg0("__asyncValues", __asyncValues);
  arg0("__makeTemplateObject", __makeTemplateObject);
  arg0("__importStar", __importStar);
  arg0("__importDefault", __importDefault);
  arg0("__classPrivateFieldGet", __classPrivateFieldGet);
  arg0("__classPrivateFieldSet", __classPrivateFieldSet);
  arg0("__classPrivateFieldIn", __classPrivateFieldIn);
  arg0("__addDisposableResource", __addDisposableResource);
  arg0("__disposeResources", __disposeResources);
  arg0("__rewriteRelativeImportExtension", __rewriteRelativeImportExtension);
});