@h3ravel/config 1.3.7 → 1.4.0

package/dist/index.js

@@ -1,92 +1,1465 @@
-import {
-  ServiceProvider,
-  __name
-} from "./chunk-Q3X4OHHO.js";
-
-// src/ConfigRepository.ts
+import "node:module";
 import { safeDot, setNested } from "@h3ravel/support";
-import path from "path";
-import { readdir } from "fs/promises";
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import { EnvParser, PathLoader } from "@h3ravel/shared";
+import "node:os";
+import "node:net";
+import { debuglog } from "node:util";
+import "node:child_process";
+import "dotenv";
+import "edge.js";
+
+//#region rolldown:runtime
+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() {
+	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 (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/ConfigRepository.ts
 var ConfigRepository = class {
-  static {
-    __name(this, "ConfigRepository");
-  }
-  app;
-  loaded = false;
-  configs = {};
-  constructor(app) {
-    this.app = app;
-  }
-  get(key, def) {
-    return safeDot(this.configs, key) ?? def;
-  }
-  /**
-   * Modify the defined configurations
-   */
-  set(key, value) {
-    setNested(this.configs, key, value);
-  }
-  async load() {
-    if (!this.loaded) {
-      const configPath = this.app.getPath("config");
-      const files = (await readdir(configPath)).filter((e) => {
-        return !e.includes(".d.ts") && !e.includes(".map");
-      });
-      for (let i = 0; i < files.length; i++) {
-        const configModule = await import(path.join(configPath, files[i]));
-        const name = files[i].replaceAll(/\.ts|\.js/g, "");
-        if (typeof configModule.default === "function") {
-          this.configs[name] = configModule.default(this.app);
-        }
-      }
-      this.loaded = true;
-    }
-    return this;
-  }
+	loaded = false;
+	configs = {};
+	constructor(app) {
+		this.app = app;
+	}
+	get(key, def) {
+		return safeDot(this.configs, key) ?? def;
+	}
+	/**
+	* Modify the defined configurations
+	*/
+	set(key, value) {
+		setNested(this.configs, key, value);
+	}
+	async load() {
+		if (!this.loaded) {
+			const configPath = this.app.getPath("config");
+			const files = (await readdir(configPath)).filter((e) => {
+				return !e.includes(".d.ts") && !e.includes(".d.cts") && !e.includes(".map");
+			});
+			for (let i = 0; i < files.length; i++) {
+				const configModule = await import(path.join(configPath, files[i]));
+				const name = files[i].replaceAll(/\.ts|\.js/g, "");
+				if (typeof configModule.default === "function") this.configs[name] = configModule.default(this.app);
+			}
+			this.loaded = true;
+		}
+		return this;
+	}
 };
 
-// src/EnvLoader.ts
-import { safeDot as safeDot2 } from "@h3ravel/support";
+//#endregion
+//#region src/EnvLoader.ts
 var EnvLoader = class {
-  static {
-    __name(this, "EnvLoader");
-  }
-  _app;
-  constructor(_app) {
-    this._app = _app;
-  }
-  get(key, def) {
-    return safeDot2(process.env, key) ?? def;
-  }
+	constructor(_app) {
+		this._app = _app;
+	}
+	get(key, def) {
+		return safeDot(EnvParser.parse(process.env), key) ?? def;
+	}
 };
 
-// src/Providers/ConfigServiceProvider.ts
-var ConfigServiceProvider = class extends ServiceProvider {
-  static {
-    __name(this, "ConfigServiceProvider");
-  }
-  static priority = 998;
-  // public static order = 'before:CoreServiceProvider';
-  async register() {
-    this.app.singleton("env", () => {
-      return new EnvLoader(this.app).get;
-    });
-    const repo = new ConfigRepository(this.app);
-    await repo.load();
-    this.app.singleton("config", () => {
-      return {
-        get: /* @__PURE__ */ __name((key, def) => repo.get(key, def), "get"),
-        set: repo.set
-      };
-    });
-    this.app.make("http.app").use((e) => {
-      repo.set("app.url", e.url.origin);
-    });
-  }
+//#endregion
+//#region src/Helpers.ts
+var Helpers = class {};
+
+//#endregion
+//#region ../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
+var require_Reflect = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/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.
+	***************************************************************************** */
+	var Reflect$1;
+	(function(Reflect$2) {
+		(function(factory) {
+			var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+			var exporter = makeExporter(Reflect$2);
+			if (typeof root.Reflect !== "undefined") exporter = makeExporter(root.Reflect, exporter);
+			factory(exporter, root);
+			if (typeof root.Reflect === "undefined") root.Reflect = Reflect$2;
+			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 (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: supportsCreate ? function() {
+					return MakeDictionary(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);
+			/**
+			* Applies a set of decorators to a property of a target object.
+			* @param decorators An array of decorators.
+			* @param target The target object.
+			* @param propertyKey (Optional) The property key to decorate.
+			* @param attributes (Optional) The property descriptor for the target key.
+			* @remarks Decorators are applied in reverse order.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     Example = Reflect.decorate(decoratorsArray, Example);
+			*
+			*     // property (on constructor)
+			*     Reflect.decorate(decoratorsArray, Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     Reflect.decorate(decoratorsArray, Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     Object.defineProperty(Example, "staticMethod",
+			*         Reflect.decorate(decoratorsArray, Example, "staticMethod",
+			*             Object.getOwnPropertyDescriptor(Example, "staticMethod")));
+			*
+			*     // method (on prototype)
+			*     Object.defineProperty(Example.prototype, "method",
+			*         Reflect.decorate(decoratorsArray, Example.prototype, "method",
+			*             Object.getOwnPropertyDescriptor(Example.prototype, "method")));
+			*
+			*/
+			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);
+			/**
+			* A default metadata decorator factory that can be used on a class, class member, or parameter.
+			* @param metadataKey The key for the metadata entry.
+			* @param metadataValue The value for the metadata entry.
+			* @returns A decorator function.
+			* @remarks
+			* If `metadataKey` is already defined for the target and target key, the
+			* metadataValue for that key will be overwritten.
+			* @example
+			*
+			*     // constructor
+			*     @Reflect.metadata(key, value)
+			*     class Example {
+			*     }
+			*
+			*     // property (on constructor, TypeScript only)
+			*     class Example {
+			*         @Reflect.metadata(key, value)
+			*         static staticProperty;
+			*     }
+			*
+			*     // property (on prototype, TypeScript only)
+			*     class Example {
+			*         @Reflect.metadata(key, value)
+			*         property;
+			*     }
+			*
+			*     // method (on constructor)
+			*     class Example {
+			*         @Reflect.metadata(key, value)
+			*         static staticMethod() { }
+			*     }
+			*
+			*     // method (on prototype)
+			*     class Example {
+			*         @Reflect.metadata(key, value)
+			*         method() { }
+			*     }
+			*
+			*/
+			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);
+			/**
+			* Define a unique metadata entry on the target.
+			* @param metadataKey A key used to store and retrieve metadata.
+			* @param metadataValue A value that contains attached metadata.
+			* @param target The target object on which to define metadata.
+			* @param propertyKey (Optional) The property key for the target.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     Reflect.defineMetadata("custom:annotation", options, Example);
+			*
+			*     // property (on constructor)
+			*     Reflect.defineMetadata("custom:annotation", options, Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     Reflect.defineMetadata("custom:annotation", options, Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "method");
+			*
+			*     // decorator factory as metadata-producing annotation.
+			*     function MyAnnotation(options): Decorator {
+			*         return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key);
+			*     }
+			*
+			*/
+			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);
+			/**
+			* Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+			* @param metadataKey A key used to store and retrieve metadata.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.hasMetadata("custom:annotation", Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
+			*
+			*/
+			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);
+			/**
+			* Gets a value indicating whether the target object has the provided metadata key defined.
+			* @param metadataKey A key used to store and retrieve metadata.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.hasOwnMetadata("custom:annotation", Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
+			*
+			*/
+			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);
+			/**
+			* Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+			* @param metadataKey A key used to store and retrieve metadata.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.getMetadata("custom:annotation", Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
+			*
+			*/
+			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);
+			/**
+			* Gets the metadata value for the provided metadata key on the target object.
+			* @param metadataKey A key used to store and retrieve metadata.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.getOwnMetadata("custom:annotation", Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
+			*
+			*/
+			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);
+			/**
+			* Gets the metadata keys defined on the target object or its prototype chain.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns An array of unique metadata keys.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.getMetadataKeys(Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.getMetadataKeys(Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.getMetadataKeys(Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.getMetadataKeys(Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.getMetadataKeys(Example.prototype, "method");
+			*
+			*/
+			function getMetadataKeys(target, propertyKey) {
+				if (!IsObject(target)) throw new TypeError();
+				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+				return OrdinaryMetadataKeys(target, propertyKey);
+			}
+			exporter("getMetadataKeys", getMetadataKeys);
+			/**
+			* Gets the unique metadata keys defined on the target object.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns An array of unique metadata keys.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.getOwnMetadataKeys(Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
+			*
+			*/
+			function getOwnMetadataKeys(target, propertyKey) {
+				if (!IsObject(target)) throw new TypeError();
+				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+				return OrdinaryOwnMetadataKeys(target, propertyKey);
+			}
+			exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+			/**
+			* Deletes the metadata entry from the target object with the provided key.
+			* @param metadataKey A key used to store and retrieve metadata.
+			* @param target The target object on which the metadata is defined.
+			* @param propertyKey (Optional) The property key for the target.
+			* @returns `true` if the metadata entry was found and deleted; otherwise, false.
+			* @example
+			*
+			*     class Example {
+			*         // property declarations are not part of ES6, though they are valid in TypeScript:
+			*         // static staticProperty;
+			*         // property;
+			*
+			*         constructor(p) { }
+			*         static staticMethod(p) { }
+			*         method(p) { }
+			*     }
+			*
+			*     // constructor
+			*     result = Reflect.deleteMetadata("custom:annotation", Example);
+			*
+			*     // property (on constructor)
+			*     result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
+			*
+			*     // property (on prototype)
+			*     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
+			*
+			*     // method (on constructor)
+			*     result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
+			*
+			*     // method (on prototype)
+			*     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
+			*
+			*/
+			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, 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) {
+				if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) 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, false);
+				if (IsUndefined(provider)) return false;
+				return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+			}
+			function OrdinaryGetMetadata(MetadataKey, O, P) {
+				if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+				var parent = OrdinaryGetPrototypeOf(O);
+				if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);
+			}
+			function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+				var provider = GetMetadataProvider(O, P, false);
+				if (IsUndefined(provider)) return;
+				return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+			}
+			function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+				GetMetadataProvider(O, P, true).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, 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);
+				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;
+			}
+			/**
+			* Creates a registry used to allow multiple `reflect-metadata` providers.
+			*/
+			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;
+									var provider = IteratorValue(next);
+									if (provider.isProviderFor(O, P)) {
+										IteratorClose(iterator);
+										return provider;
+									}
+								}
+							}
+						}
+					}
+					if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) return fallback;
+				}
+				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;
+				}
+			}
+			/**
+			* Gets or creates the shared registry of metadata providers.
+			*/
+			function GetOrCreateMetadataRegistry() {
+				var metadataRegistry$1;
+				if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) metadataRegistry$1 = root.Reflect[registrySymbol];
+				if (IsUndefined(metadataRegistry$1)) metadataRegistry$1 = CreateMetadataRegistry();
+				if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) Object.defineProperty(root.Reflect, registrySymbol, {
+					enumerable: false,
+					configurable: false,
+					writable: false,
+					value: metadataRegistry$1
+				});
+				return metadataRegistry$1;
+			}
+			function CreateMetadataProvider(registry) {
+				var metadata$1 = new _WeakMap();
+				var provider = {
+					isProviderFor: function(O, P) {
+						var targetMetadata = metadata$1.get(O);
+						if (IsUndefined(targetMetadata)) return false;
+						return targetMetadata.has(P);
+					},
+					OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata$1,
+					OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata$1,
+					OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata$1,
+					OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys$1,
+					OrdinaryDeleteMetadata
+				};
+				metadataRegistry.registerProvider(provider);
+				return provider;
+				function GetOrCreateMetadataMap(O, P, Create) {
+					var targetMetadata = metadata$1.get(O);
+					var createdTargetMetadata = false;
+					if (IsUndefined(targetMetadata)) {
+						if (!Create) return void 0;
+						targetMetadata = new _Map();
+						metadata$1.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) metadata$1.delete(O);
+							throw new Error("Wrong provider for target.");
+						}
+					}
+					return metadataMap;
+				}
+				function OrdinaryHasOwnMetadata$1(MetadataKey, O, P) {
+					var metadataMap = GetOrCreateMetadataMap(O, P, false);
+					if (IsUndefined(metadataMap)) return false;
+					return ToBoolean(metadataMap.has(MetadataKey));
+				}
+				function OrdinaryGetOwnMetadata$1(MetadataKey, O, P) {
+					var metadataMap = GetOrCreateMetadataMap(O, P, false);
+					if (IsUndefined(metadataMap)) return void 0;
+					return metadataMap.get(MetadataKey);
+				}
+				function OrdinaryDefineOwnMetadata$1(MetadataKey, MetadataValue, O, P) {
+					GetOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
+				}
+				function OrdinaryOwnMetadataKeys$1(O, P) {
+					var keys = [];
+					var metadataMap = GetOrCreateMetadataMap(O, P, 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, false);
+					if (IsUndefined(metadataMap)) return false;
+					if (!metadataMap.delete(MetadataKey)) return false;
+					if (metadataMap.size === 0) {
+						var targetMetadata = metadata$1.get(O);
+						if (!IsUndefined(targetMetadata)) {
+							targetMetadata.delete(P);
+							if (targetMetadata.size === 0) metadata$1.delete(targetMetadata);
+						}
+					}
+					return true;
+				}
+			}
+			function CreateFallbackProvider(reflect) {
+				var defineMetadata$1 = reflect.defineMetadata, hasOwnMetadata$1 = reflect.hasOwnMetadata, getOwnMetadata$1 = reflect.getOwnMetadata, getOwnMetadataKeys$1 = reflect.getOwnMetadataKeys, deleteMetadata$1 = reflect.deleteMetadata;
+				var metadataOwner = new _WeakMap();
+				return {
+					isProviderFor: function(O, P) {
+						var metadataPropertySet = metadataOwner.get(O);
+						if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) return true;
+						if (getOwnMetadataKeys$1(O, P).length) {
+							if (IsUndefined(metadataPropertySet)) {
+								metadataPropertySet = new _Set();
+								metadataOwner.set(O, metadataPropertySet);
+							}
+							metadataPropertySet.add(P);
+							return true;
+						}
+						return false;
+					},
+					OrdinaryDefineOwnMetadata: defineMetadata$1,
+					OrdinaryHasOwnMetadata: hasOwnMetadata$1,
+					OrdinaryGetOwnMetadata: getOwnMetadata$1,
+					OrdinaryOwnMetadataKeys: getOwnMetadataKeys$1,
+					OrdinaryDeleteMetadata: deleteMetadata$1
+				};
+			}
+			/**
+			* Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,
+			* then this module's metadata provider is assigned to the object.
+			*/
+			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.");
+				}
+			}
+			function CreateMapPolyfill() {
+				var cacheSentinel = {};
+				var arraySentinel = [];
+				var MapIterator = function() {
+					function MapIterator$1(keys, values, selector) {
+						this._index = 0;
+						this._keys = keys;
+						this._values = values;
+						this._selector = selector;
+					}
+					MapIterator$1.prototype["@@iterator"] = function() {
+						return this;
+					};
+					MapIterator$1.prototype[iteratorSymbol] = function() {
+						return this;
+					};
+					MapIterator$1.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
+						};
+					};
+					MapIterator$1.prototype.throw = function(error) {
+						if (this._index >= 0) {
+							this._index = -1;
+							this._keys = arraySentinel;
+							this._values = arraySentinel;
+						}
+						throw error;
+					};
+					MapIterator$1.prototype.return = function(value) {
+						if (this._index >= 0) {
+							this._index = -1;
+							this._keys = arraySentinel;
+							this._values = arraySentinel;
+						}
+						return {
+							value,
+							done: true
+						};
+					};
+					return MapIterator$1;
+				}();
+				return function() {
+					function Map$1() {
+						this._keys = [];
+						this._values = [];
+						this._cacheKey = cacheSentinel;
+						this._cacheIndex = -2;
+					}
+					Object.defineProperty(Map$1.prototype, "size", {
+						get: function() {
+							return this._keys.length;
+						},
+						enumerable: true,
+						configurable: true
+					});
+					Map$1.prototype.has = function(key) {
+						return this._find(key, false) >= 0;
+					};
+					Map$1.prototype.get = function(key) {
+						var index = this._find(key, false);
+						return index >= 0 ? this._values[index] : void 0;
+					};
+					Map$1.prototype.set = function(key, value) {
+						var index = this._find(key, true);
+						this._values[index] = value;
+						return this;
+					};
+					Map$1.prototype.delete = function(key) {
+						var index = this._find(key, 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 (SameValueZero(key, this._cacheKey)) {
+								this._cacheKey = cacheSentinel;
+								this._cacheIndex = -2;
+							}
+							return true;
+						}
+						return false;
+					};
+					Map$1.prototype.clear = function() {
+						this._keys.length = 0;
+						this._values.length = 0;
+						this._cacheKey = cacheSentinel;
+						this._cacheIndex = -2;
+					};
+					Map$1.prototype.keys = function() {
+						return new MapIterator(this._keys, this._values, getKey);
+					};
+					Map$1.prototype.values = function() {
+						return new MapIterator(this._keys, this._values, getValue);
+					};
+					Map$1.prototype.entries = function() {
+						return new MapIterator(this._keys, this._values, getEntry);
+					};
+					Map$1.prototype["@@iterator"] = function() {
+						return this.entries();
+					};
+					Map$1.prototype[iteratorSymbol] = function() {
+						return this.entries();
+					};
+					Map$1.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 Map$1;
+				}();
+				function getKey(key, _) {
+					return key;
+				}
+				function getValue(_, value) {
+					return value;
+				}
+				function getEntry(key, value) {
+					return [key, value];
+				}
+			}
+			function CreateSetPolyfill() {
+				return function() {
+					function Set$1() {
+						this._map = new _Map();
+					}
+					Object.defineProperty(Set$1.prototype, "size", {
+						get: function() {
+							return this._map.size;
+						},
+						enumerable: true,
+						configurable: true
+					});
+					Set$1.prototype.has = function(value) {
+						return this._map.has(value);
+					};
+					Set$1.prototype.add = function(value) {
+						return this._map.set(value, value), this;
+					};
+					Set$1.prototype.delete = function(value) {
+						return this._map.delete(value);
+					};
+					Set$1.prototype.clear = function() {
+						this._map.clear();
+					};
+					Set$1.prototype.keys = function() {
+						return this._map.keys();
+					};
+					Set$1.prototype.values = function() {
+						return this._map.keys();
+					};
+					Set$1.prototype.entries = function() {
+						return this._map.entries();
+					};
+					Set$1.prototype["@@iterator"] = function() {
+						return this.keys();
+					};
+					Set$1.prototype[iteratorSymbol] = function() {
+						return this.keys();
+					};
+					return Set$1;
+				}();
+			}
+			function CreateWeakMapPolyfill() {
+				var UUID_SIZE = 16;
+				var keys = HashMap.create();
+				var rootKey = CreateUniqueKey();
+				return function() {
+					function WeakMap$1() {
+						this._key = CreateUniqueKey();
+					}
+					WeakMap$1.prototype.has = function(target) {
+						var table = GetOrCreateWeakMapTable(target, false);
+						return table !== void 0 ? HashMap.has(table, this._key) : false;
+					};
+					WeakMap$1.prototype.get = function(target) {
+						var table = GetOrCreateWeakMapTable(target, false);
+						return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+					};
+					WeakMap$1.prototype.set = function(target, value) {
+						var table = GetOrCreateWeakMapTable(target, true);
+						table[this._key] = value;
+						return this;
+					};
+					WeakMap$1.prototype.delete = function(target) {
+						var table = GetOrCreateWeakMapTable(target, false);
+						return table !== void 0 ? delete table[this._key] : false;
+					};
+					WeakMap$1.prototype.clear = function() {
+						this._key = CreateUniqueKey();
+					};
+					return WeakMap$1;
+				}();
+				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") {
+						var array = new Uint8Array(size);
+						if (typeof crypto !== "undefined") crypto.getRandomValues(array);
+						else if (typeof msCrypto !== "undefined") msCrypto.getRandomValues(array);
+						else FillRandomBytes(array, size);
+						return array;
+					}
+					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;
+			}
+		});
+	})(Reflect$1 || (Reflect$1 = {}));
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/address@2.0.3/node_modules/address/dist/esm/address.js
+var import_Reflect = /* @__PURE__ */ __toESM(require_Reflect(), 1);
+
+//#endregion
+//#region ../../node_modules/.pnpm/detect-port@2.1.0/node_modules/detect-port/dist/esm/detect-port.js
+const debug$1 = debuglog("detect-port");
+
+//#endregion
+//#region ../../node_modules/.pnpm/detect-port@2.1.0/node_modules/detect-port/dist/esm/wait-port.js
+const debug = debuglog("detect-port:wait-port");
+
+//#endregion
+//#region ../../node_modules/.pnpm/dotenv-expand@12.0.3/node_modules/dotenv-expand/lib/main.js
+var require_main = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/dotenv-expand@12.0.3/node_modules/dotenv-expand/lib/main.js": ((exports, module) => {
+	function _resolveEscapeSequences(value) {
+		return value.replace(/\\\$/g, "$");
+	}
+	function expandValue(value, processEnv, runningParsed) {
+		const env$1 = {
+			...runningParsed,
+			...processEnv
+		};
+		const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+		let result = value;
+		let match;
+		const seen = /* @__PURE__ */ new Set();
+		while ((match = regex.exec(result)) !== null) {
+			seen.add(result);
+			const [template, bracedExpression, unbracedExpression] = match;
+			const expression = bracedExpression || unbracedExpression;
+			const opMatch = expression.match(/(:\+|\+|:-|-)/);
+			const splitter = opMatch ? opMatch[0] : null;
+			const r = expression.split(splitter);
+			let defaultValue;
+			let value$1;
+			const key = r.shift();
+			if ([":+", "+"].includes(splitter)) {
+				defaultValue = env$1[key] ? r.join(splitter) : "";
+				value$1 = null;
+			} else {
+				defaultValue = r.join(splitter);
+				value$1 = env$1[key];
+			}
+			if (value$1) if (seen.has(value$1)) result = result.replace(template, defaultValue);
+			else result = result.replace(template, value$1);
+			else result = result.replace(template, defaultValue);
+			if (result === runningParsed[key]) break;
+			regex.lastIndex = 0;
+		}
+		return result;
+	}
+	function expand(options) {
+		const runningParsed = {};
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		for (const key in options.parsed) {
+			let value = options.parsed[key];
+			if (processEnv[key] && processEnv[key] !== value) value = processEnv[key];
+			else value = expandValue(value, processEnv, runningParsed);
+			options.parsed[key] = _resolveEscapeSequences(value);
+			runningParsed[key] = _resolveEscapeSequences(value);
+		}
+		for (const processKey in options.parsed) processEnv[processKey] = options.parsed[processKey];
+		return options;
+	}
+	module.exports.expand = expand;
+}) });
+
+//#endregion
+//#region ../core/dist/index.js
+var import_main = /* @__PURE__ */ __toESM(require_main(), 1);
+var ServiceProvider = class {
+	/**
+	* Sort order
+	*/
+	static order;
+	/**
+	* Sort priority
+	*/
+	static priority = 0;
+	/**
+	* Indicate that this service provider only runs in console
+	*/
+	static console = false;
+	/**
+	* List of registered console commands
+	*/
+	registeredCommands;
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	/**
+	* An array of console commands to register.
+	*/
+	commands(commands) {
+		this.registeredCommands = commands;
+	}
 };
-export {
-  ConfigRepository,
-  ConfigServiceProvider,
-  EnvLoader
+
+//#endregion
+//#region src/Providers/ConfigServiceProvider.ts
+/**
+* Loads configuration and environment files.
+* 
+* Load .env and merge with config files.
+* Bind ConfigRepository to the container.
+* 
+* Auto-Registered
+*/
+var ConfigServiceProvider = class extends ServiceProvider {
+	static priority = 998;
+	async register() {
+		/**
+		* Create singleton to load env
+		*/
+		this.app.singleton("env", () => {
+			const env$1 = new EnvLoader(this.app).get;
+			globalThis.env = env$1;
+			return env$1;
+		});
+		/**
+		* Initialize the configuration through the repository
+		*/
+		const repo = new ConfigRepository(this.app);
+		await repo.load();
+		/**
+		* Create singleton to load configurations
+		*/
+		this.app.singleton("config", () => {
+			const config = {
+				get: (key, def) => repo.get(key, def),
+				set: repo.set
+			};
+			globalThis.config = ((key, def) => {
+				if (!key || typeof key === "string") return config.get(key, def);
+				Object.entries(key).forEach(([key$1, value]) => {
+					config.set(key$1, value);
+				});
+			});
+			return config;
+		});
+		this.app.make("http.app").use((e) => {
+			repo.set("app.url", e.url.origin);
+		});
+	}
 };
+
+//#endregion
+export { ConfigRepository, ConfigServiceProvider, EnvLoader, Helpers };
 //# sourceMappingURL=index.js.map