var __create = Object.create; var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; var __commonJS = (cb, mod) => function __require() { return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; }; 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( // If the importer is in node compatibility mode or this is not an ESM // file that has been converted to a CommonJS file using a Babel- // compatible transform (i.e. "__esModule" has not been set), then set // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); var __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; }; // node_modules/reflect-metadata/Reflect.js var require_Reflect = __commonJS({ "node_modules/reflect-metadata/Reflect.js"() { var Reflect2; (function(Reflect3) { (function(factory) { var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis(); var exporter = makeExporter(Reflect3); if (typeof root.Reflect !== "undefined") { exporter = makeExporter(root.Reflect, exporter); } factory(exporter, root); if (typeof root.Reflect === "undefined") { root.Reflect = Reflect3; } function makeExporter(target, previous) { return function(key, value) { Object.defineProperty(target, key, { configurable: true, writable: true, value }); if (previous) previous(key, value); }; } function functionThis() { try { return Function("return this;")(); } catch (_) { } } function indirectEvalThis() { try { return (void 0, eval)("(function() { return this; })()"); } catch (_) { } } function sloppyModeThis() { return functionThis() || indirectEvalThis(); } })(function(exporter, root) { 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 _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill(); var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill(); var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill(); var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0; var metadataRegistry = GetOrCreateMetadataRegistry(); var metadataProvider = CreateMetadataProvider(metadataRegistry); 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); if (!IsObject(target)) throw new TypeError(); if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey); var provider = GetMetadataProvider( target, propertyKey, /*Create*/ false ); if (IsUndefined(provider)) return false; return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey); } 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 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 provider = GetMetadataProvider( O, P, /*Create*/ false ); if (IsUndefined(provider)) return false; return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P)); } 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 provider = GetMetadataProvider( O, P, /*Create*/ false ); if (IsUndefined(provider)) return; return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P); } function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { var provider = GetMetadataProvider( O, P, /*Create*/ true ); provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P); } 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 provider = GetMetadataProvider( O, P, /*create*/ false ); if (!provider) { return []; } return provider.OrdinaryOwnMetadataKeys(O, P); } 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 SameValueZero(x, y) { return x === y || x !== x && y !== y; } 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 CreateMetadataRegistry() { var fallback; if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") { fallback = CreateFallbackProvider(root.Reflect); } var first; var second; var rest; var targetProviderMap = new _WeakMap(); var registry = { registerProvider, getProvider, setProvider }; return registry; function registerProvider(provider) { if (!Object.isExtensible(registry)) { throw new Error("Cannot add provider to a frozen registry."); } switch (true) { case fallback === provider: break; case IsUndefined(first): first = provider; break; case first === provider: break; case IsUndefined(second): second = provider; break; case second === provider: break; default: if (rest === void 0) rest = new _Set(); rest.add(provider); break; } } function getProviderNoCache(O, P) { if (!IsUndefined(first)) { if (first.isProviderFor(O, P)) return first; if (!IsUndefined(second)) { if (second.isProviderFor(O, P)) return first; if (!IsUndefined(rest)) { var iterator = GetIterator(rest); while (true) { var next = IteratorStep(iterator); if (!next) { return void 0; } var provider = IteratorValue(next); if (provider.isProviderFor(O, P)) { IteratorClose(iterator); return provider; } } } } } if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) { return fallback; } return void 0; } function getProvider(O, P) { var providerMap = targetProviderMap.get(O); var provider; if (!IsUndefined(providerMap)) { provider = providerMap.get(P); } if (!IsUndefined(provider)) { return provider; } provider = getProviderNoCache(O, P); if (!IsUndefined(provider)) { if (IsUndefined(providerMap)) { providerMap = new _Map(); targetProviderMap.set(O, providerMap); } providerMap.set(P, provider); } return provider; } function hasProvider(provider) { if (IsUndefined(provider)) throw new TypeError(); return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider); } function setProvider(O, P, provider) { if (!hasProvider(provider)) { throw new Error("Metadata provider not registered."); } var existingProvider = getProvider(O, P); if (existingProvider !== provider) { if (!IsUndefined(existingProvider)) { return false; } var providerMap = targetProviderMap.get(O); if (IsUndefined(providerMap)) { providerMap = new _Map(); targetProviderMap.set(O, providerMap); } providerMap.set(P, provider); } return true; } } function GetOrCreateMetadataRegistry() { var metadataRegistry2; if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) { metadataRegistry2 = root.Reflect[registrySymbol]; } if (IsUndefined(metadataRegistry2)) { metadataRegistry2 = CreateMetadataRegistry(); } if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) { Object.defineProperty(root.Reflect, registrySymbol, { enumerable: false, configurable: false, writable: false, value: metadataRegistry2 }); } return metadataRegistry2; } function CreateMetadataProvider(registry) { var metadata2 = new _WeakMap(); var provider = { isProviderFor: function(O, P) { var targetMetadata = metadata2.get(O); if (IsUndefined(targetMetadata)) return false; return targetMetadata.has(P); }, OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2, OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2, OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2, OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2, OrdinaryDeleteMetadata }; metadataRegistry.registerProvider(provider); return provider; function GetOrCreateMetadataMap(O, P, Create) { var targetMetadata = metadata2.get(O); var createdTargetMetadata = false; if (IsUndefined(targetMetadata)) { if (!Create) return void 0; targetMetadata = new _Map(); metadata2.set(O, targetMetadata); createdTargetMetadata = true; } var metadataMap = targetMetadata.get(P); if (IsUndefined(metadataMap)) { if (!Create) return void 0; metadataMap = new _Map(); targetMetadata.set(P, metadataMap); if (!registry.setProvider(O, P, provider)) { targetMetadata.delete(P); if (createdTargetMetadata) { metadata2.delete(O); } throw new Error("Wrong provider for target."); } } return metadataMap; } function OrdinaryHasOwnMetadata2(MetadataKey, O, P) { var metadataMap = GetOrCreateMetadataMap( O, P, /*Create*/ false ); if (IsUndefined(metadataMap)) return false; return ToBoolean(metadataMap.has(MetadataKey)); } function OrdinaryGetOwnMetadata2(MetadataKey, O, P) { var metadataMap = GetOrCreateMetadataMap( O, P, /*Create*/ false ); if (IsUndefined(metadataMap)) return void 0; return metadataMap.get(MetadataKey); } function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) { var metadataMap = GetOrCreateMetadataMap( O, P, /*Create*/ true ); metadataMap.set(MetadataKey, MetadataValue); } function OrdinaryOwnMetadataKeys2(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 OrdinaryDeleteMetadata(MetadataKey, O, P) { var metadataMap = GetOrCreateMetadataMap( O, P, /*Create*/ false ); if (IsUndefined(metadataMap)) return false; if (!metadataMap.delete(MetadataKey)) return false; if (metadataMap.size === 0) { var targetMetadata = metadata2.get(O); if (!IsUndefined(targetMetadata)) { targetMetadata.delete(P); if (targetMetadata.size === 0) { metadata2.delete(targetMetadata); } } } return true; } } function CreateFallbackProvider(reflect) { var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata; var metadataOwner = new _WeakMap(); var provider = { isProviderFor: function(O, P) { var metadataPropertySet = metadataOwner.get(O); if (!IsUndefined(metadataPropertySet)) { return metadataPropertySet.has(P); } if (getOwnMetadataKeys2(O, P).length) { if (IsUndefined(metadataPropertySet)) { metadataPropertySet = new _Set(); metadataOwner.set(O, metadataPropertySet); } metadataPropertySet.add(P); return true; } return false; }, OrdinaryDefineOwnMetadata: defineMetadata2, OrdinaryHasOwnMetadata: hasOwnMetadata2, OrdinaryGetOwnMetadata: getOwnMetadata2, OrdinaryOwnMetadataKeys: getOwnMetadataKeys2, OrdinaryDeleteMetadata: deleteMetadata2 }; return provider; } function GetMetadataProvider(O, P, Create) { var registeredProvider = metadataRegistry.getProvider(O, P); if (!IsUndefined(registeredProvider)) { return registeredProvider; } if (Create) { if (metadataRegistry.setProvider(O, P, metadataProvider)) { return metadataProvider; } throw new Error("Illegal state."); } return void 0; } 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 index2 = this._index; if (index2 >= 0 && index2 < this._keys.length) { var result = this._selector(this._keys[index2], this._values[index2]); if (index2 + 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; }() ); var Map2 = ( /** @class */ function() { function Map3() { this._keys = []; this._values = []; this._cacheKey = cacheSentinel; this._cacheIndex = -2; } Object.defineProperty(Map3.prototype, "size", { get: function() { return this._keys.length; }, enumerable: true, configurable: true }); Map3.prototype.has = function(key) { return this._find( key, /*insert*/ false ) >= 0; }; Map3.prototype.get = function(key) { var index2 = this._find( key, /*insert*/ false ); return index2 >= 0 ? this._values[index2] : void 0; }; Map3.prototype.set = function(key, value) { var index2 = this._find( key, /*insert*/ true ); this._values[index2] = value; return this; }; Map3.prototype.delete = function(key) { var index2 = this._find( key, /*insert*/ false ); if (index2 >= 0) { var size = this._keys.length; for (var i = index2 + 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 (SameValueZero(key, this._cacheKey)) { this._cacheKey = cacheSentinel; this._cacheIndex = -2; } return true; } return false; }; Map3.prototype.clear = function() { this._keys.length = 0; this._values.length = 0; this._cacheKey = cacheSentinel; this._cacheIndex = -2; }; Map3.prototype.keys = function() { return new MapIterator(this._keys, this._values, getKey); }; Map3.prototype.values = function() { return new MapIterator(this._keys, this._values, getValue); }; Map3.prototype.entries = function() { return new MapIterator(this._keys, this._values, getEntry); }; Map3.prototype["@@iterator"] = function() { return this.entries(); }; Map3.prototype[iteratorSymbol] = function() { return this.entries(); }; Map3.prototype._find = function(key, insert) { if (!SameValueZero(this._cacheKey, key)) { this._cacheIndex = -1; for (var i = 0; i < this._keys.length; i++) { if (SameValueZero(this._keys[i], key)) { this._cacheIndex = i; break; } } } if (this._cacheIndex < 0 && insert) { this._cacheIndex = this._keys.length; this._keys.push(key); this._values.push(void 0); } return this._cacheIndex; }; return Map3; }() ); return Map2; function getKey(key, _) { return key; } function getValue(_, value) { return value; } function getEntry(key, value) { return [key, value]; } } function CreateSetPolyfill() { var Set2 = ( /** @class */ function() { function Set3() { this._map = new _Map(); } Object.defineProperty(Set3.prototype, "size", { get: function() { return this._map.size; }, enumerable: true, configurable: true }); Set3.prototype.has = function(value) { return this._map.has(value); }; Set3.prototype.add = function(value) { return this._map.set(value, value), this; }; Set3.prototype.delete = function(value) { return this._map.delete(value); }; Set3.prototype.clear = function() { this._map.clear(); }; Set3.prototype.keys = function() { return this._map.keys(); }; Set3.prototype.values = function() { return this._map.keys(); }; Set3.prototype.entries = function() { return this._map.entries(); }; Set3.prototype["@@iterator"] = function() { return this.keys(); }; Set3.prototype[iteratorSymbol] = function() { return this.keys(); }; return Set3; }() ); 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, create) { if (!hasOwn.call(target, rootKey)) { if (!create) 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 = {})); } }); // src/decorators/dbconn.ts import { mongoose } from "@typegoose/typegoose"; function dbconn(name) { return (target) => { name = name || "main"; const dbName = ("db_" + name).toUpperCase(); const url = process.env[dbName]; target["db"] = mongoose.createConnection(url, {}); }; } // src/decorators/nojson.ts var import_reflect_metadata = __toESM(require_Reflect(), 1); // src/decorators/singleton.ts var SINGLETON_KEY = Symbol(); var singleton = (classTarget) => new Proxy(classTarget, { construct(target, argumentsList, newTarget) { if (target.prototype !== newTarget.prototype) { return Reflect.construct(target, argumentsList, newTarget); } if (!target[SINGLETON_KEY]) { target[SINGLETON_KEY] = Reflect.construct(target, argumentsList, newTarget); } return target[SINGLETON_KEY]; } }); // src/decorators/nojson.ts var NoJsonClass = class { noJsonPropSet = /* @__PURE__ */ new Set(); addKey(className, propertyKey) { this.noJsonPropSet.add(className + "_" + propertyKey); } checkExist(className, propertyKey) { return this.noJsonPropSet.has(className + "_" + propertyKey); } }; NoJsonClass = __decorateClass([ singleton ], NoJsonClass); function noJson() { return function(target, propertyKey) { new NoJsonClass().addKey(target.constructor.name, propertyKey); }; } function checkJson(target, propertyKey) { return !new NoJsonClass().checkExist(target.constructor.modelName, propertyKey); } // src/common/AsyncQueue.ts function createAsyncQueue(opts = { dedupeConcurrent: false }) { const { dedupeConcurrent } = opts; let queue = []; let running; let nextPromise = new DeferredPromise(); const push = (task) => { let taskPromise = new DeferredPromise(); if (dedupeConcurrent) { queue = []; if (nextPromise.started) nextPromise = new DeferredPromise(); taskPromise = nextPromise; } queue.push(() => { taskPromise.started = true; task().then(taskPromise.resolve).catch(taskPromise.reject); return taskPromise.promise; }); if (!running) running = start(); return taskPromise.promise; }; const start = async () => { while (queue.length) { const task = queue.shift(); await task().catch(() => { }); } running = void 0; }; return { push, flush: () => running || Promise.resolve(), get size() { return queue.length; } }; } var DeferredPromise = class { started = false; resolve = () => { }; reject = () => { }; promise; constructor() { this.promise = new Promise((res, rej) => { this.resolve = res; this.reject = rej; }); } }; // src/models/UserLog.ts import { getModelForClass, index, modelOptions, mongoose as mongoose2, prop } from "@typegoose/typegoose"; import { Severity } from "@typegoose/typegoose/lib/internal/constants"; // src/models/Base.ts import { ObjectId } from "bson"; var jsonExcludeKeys = ["updatedAt", "__v"]; var saveExcludeKeys = ["createdAt", "updatedAt", "__v", "_id"]; var isTrue = (obj) => { return obj === "true" || obj === "TRUE" || obj === "True" || obj === "on" || obj === "ON" || obj === true || obj === 1 || obj === "1" || obj === "YES" || obj === "yes"; }; var BaseModule = class { static db; updateFromReq(data) { for (let key in data) { if (saveExcludeKeys.indexOf(key) == -1) { this[key] = data[key]; } } } /** * 插入或更新 * @param condition * @param data */ static insertOrUpdate(condition, data) { return this.findOneAndUpdate(condition, data, { upsert: true, new: true, setDefaultsOnInsert: true }); } /** * 虚拟删除 * @param {string[]} ids */ static deleteVirtual(ids) { return this.updateMany( // @ts-ignore { _id: { $in: ids } }, { $set: { deleted: true, deleteTime: /* @__PURE__ */ new Date() } } ); } /** * 自定义分页查询 * @param data * @param {boolean} json */ static async pageQuery(data, json = false) { let { start, limit, page } = data; limit = +limit || 10; start = +start || (+page - 1) * limit || 0; let { opt, sort } = this.parseQueryParam(data); let records = await this.find(opt).sort(sort).skip(start).limit(limit); let total = await this.countDocuments(opt); if (json) { records.map((o) => o.toJson()); } return { records, total, start, limit }; } toJson() { let result = {}; for (let key in this._doc) { if (checkJson(this, key + "") && jsonExcludeKeys.indexOf(key) == -1) { result[key] = this[key]; } } return result; } /** * 通用的查询条件拼接方法 * @param {{}} params req.params * @param options * sort: 排序 比如: {createdAt: 1} 默认是 {_id: 1} * opt: 设置一些特殊的过滤条件, 比如{deleted: 0} * timeKey: 如果需要查询创建时间, 而且创建时间不为 createdAt, 可以用此字段设置 * matchKey: 指定关键字查询的匹配字段, 可为string或[string] * * @return {{opt: any, sort: {_id: number}}} */ static parseQueryParam(params, options) { const opt = { deleted: { $ne: true } }; let obj = this.schema.paths; for (let key in params) { if (key !== "sort" && obj.hasOwnProperty(key)) { switch (obj[key].instance) { case "String": opt[key] = { $regex: params[key], $options: "i" }; break; case "Number": opt[key] = params[key]; break; case "Array": if (Array.isArray(params[key])) { opt[key] = { $in: params[key] }; } else { opt[key] = params[key]; } break; case "Date": break; case "Boolean": opt[key] = isTrue(params[key]); break; case "ObjectID": if (/^[0-9a-fA-F]{24}$/.test(params[key])) { opt[key] = new ObjectId(params[key]); } break; } } } if (params.hasOwnProperty("key") && params["key"]) { let orArr = []; if (options?.matchKey) { if (Array.isArray(options?.matchKey)) { for (let key in options?.matchKey) { let _tmp = {}; _tmp[key] = { $regex: params["key"], $options: "i" }; orArr.push(_tmp); } } else { let _tmp = {}; _tmp[options.matchKey] = { $regex: params["key"], $options: "i" }; orArr.push(_tmp); } } else { for (let key in obj) { if (obj[key].instance === "String") { let _tmp = {}; _tmp[key] = { $regex: params["key"], $options: "i" }; orArr.push(_tmp); } } } Object.assign(opt, { $or: orArr }); } let timeKey = options?.timeKey ? options.timeKey : "createdAt"; if (params.hasOwnProperty("timeBegin") && !params.hasOwnProperty("timeEnd")) { let timeBegin = params["timeBegin"]; if (!(timeBegin instanceof Date)) { timeBegin = new Date(parseInt(timeBegin)); } opt[timeKey] = { $gte: timeBegin }; } else if (params.hasOwnProperty("timeBegin") && params.hasOwnProperty("timeEnd")) { let timeBegin = params["timeBegin"]; if (!(timeBegin instanceof Date)) { timeBegin = new Date(parseInt(timeBegin)); } let timeEnd = params["timeEnd"]; if (!(timeEnd instanceof Date)) { timeEnd = new Date(parseInt(timeEnd)); } let tmpB = {}; tmpB[timeKey] = { $gte: timeBegin }; let tmpE = {}; tmpE[timeKey] = { $lte: timeEnd }; opt["$and"] = [tmpB, tmpE]; } else if (!params.hasOwnProperty("timeBegin") && params.hasOwnProperty("timeEnd")) { let timeEnd = params["timeEnd"]; if (!(timeEnd instanceof Date)) { timeEnd = new Date(parseInt(timeEnd)); } opt[timeKey] = { $lte: timeEnd }; } if (options?.opt) { Object.assign(opt, options.opt); } let sort = { _id: 1 }; if (params.hasOwnProperty("sort")) { sort = params["sort"]; } return { opt, sort }; } getTimestampOfID() { return this._id.getTimestamp(); } }; // src/models/UserLog.ts var UserLogClass = class extends BaseModule { user; name; method; path; referer; user_agent; ip; params; }; __decorateClass([ prop() ], UserLogClass.prototype, "user", 2); __decorateClass([ prop() ], UserLogClass.prototype, "name", 2); __decorateClass([ prop() ], UserLogClass.prototype, "method", 2); __decorateClass([ prop() ], UserLogClass.prototype, "path", 2); __decorateClass([ prop() ], UserLogClass.prototype, "referer", 2); __decorateClass([ prop() ], UserLogClass.prototype, "user_agent", 2); __decorateClass([ prop() ], UserLogClass.prototype, "ip", 2); __decorateClass([ prop({ type: mongoose2.Schema.Types.Mixed }) ], UserLogClass.prototype, "params", 2); UserLogClass = __decorateClass([ dbconn(), index({ user: 1 }, { unique: false }), index({ name: 1 }, { unique: false }), modelOptions({ schemaOptions: { collection: "user_log", timestamps: true }, options: { allowMixed: Severity.ALLOW } }) ], UserLogClass); var UserLog = getModelForClass(UserLogClass, { existingConnection: UserLogClass["db"] }); // src/queue/logger.queue.ts var LoggerQueue = class { queue; constructor() { this.queue = createAsyncQueue(); } addLog(name, req, logObj = {}) { this.queue.push(async () => { const user = req.user; const ip = req.headers["x-forwarded-for"] || req.ip; const path = req.url; const params = req.method === "GET" ? req.query : req.body; const dataObj = JSON.stringify(logObj) === "{}" ? params : logObj; try { const history = new UserLog({ user: user ? user.id : "", path, method: req.method, params: dataObj, referer: req.headers["referer"], user_agent: req.headers["user-agent"], ip, name }); await history.save(); } catch (err) { logger.error("error add user log: "); logger.error(err); } }); } }; LoggerQueue = __decorateClass([ singleton ], LoggerQueue); // src/logger/logger.ts import { colorConsole } from "tracer"; var level = process.env.NODE_ENV === "production" ? "info" : "log"; var _logger = colorConsole({ dateformat: "yyyy-mm-dd HH:MM:ss.L", level }); Object.assign(_logger, { db: (name, req, logObj) => { logObj = logObj || {}; new LoggerQueue().addLog(name, req, logObj); } }); var logger = _logger; export { BaseModule, NoJsonClass, UserLog, checkJson, dbconn, logger, noJson }; /*! 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. ***************************************************************************** *) */ //# sourceMappingURL=index.js.map