4789 lines
201 KiB
JavaScript
4789 lines
201 KiB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else {
|
|
var a = factory();
|
|
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
|
|
}
|
|
})(global, () => {
|
|
return /******/ (() => { // webpackBootstrap
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
/***/ "./node_modules/reflect-metadata/Reflect.js":
|
|
/*!**************************************************!*\
|
|
!*** ./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;
|
|
(function (Reflect) {
|
|
// Metadata Proposal
|
|
// https://rbuckton.github.io/reflect-metadata/
|
|
(function (factory) {
|
|
var root = typeof global === "object" ? global :
|
|
typeof self === "object" ? self :
|
|
typeof this === "object" ? this :
|
|
Function("return this;")();
|
|
var exporter = makeExporter(Reflect);
|
|
if (typeof root.Reflect === "undefined") {
|
|
root.Reflect = Reflect;
|
|
}
|
|
else {
|
|
exporter = makeExporter(root.Reflect, exporter);
|
|
}
|
|
factory(exporter);
|
|
function makeExporter(target, previous) {
|
|
return function (key, value) {
|
|
if (typeof target[key] !== "function") {
|
|
Object.defineProperty(target, key, { configurable: true, writable: true, value: value });
|
|
}
|
|
if (previous)
|
|
previous(key, value);
|
|
};
|
|
}
|
|
})(function (exporter) {
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
// feature test for Symbol support
|
|
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"; // feature test for Object.create support
|
|
var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support
|
|
var downLevel = !supportsCreate && !supportsProto;
|
|
var HashMap = {
|
|
// create an object in dictionary mode (a.k.a. "slow" mode in v8)
|
|
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] : undefined; }
|
|
: function (map, key) { return map[key]; },
|
|
};
|
|
// Load global or shim versions of Map, Set, and WeakMap
|
|
var functionPrototype = Object.getPrototypeOf(Function);
|
|
var usePolyfill = typeof process === "object" && process.env && process.env["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true";
|
|
var _Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
|
|
var _Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
|
|
var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
|
|
// [[Metadata]] internal slot
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots
|
|
var Metadata = new _WeakMap();
|
|
/**
|
|
* 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 = undefined;
|
|
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);
|
|
// 4.1.2 Reflect.metadata(metadataKey, metadataValue)
|
|
// https://rbuckton.github.io/reflect-metadata/#reflect.metadata
|
|
/**
|
|
* 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);
|
|
var metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);
|
|
if (IsUndefined(metadataMap))
|
|
return false;
|
|
if (!metadataMap.delete(metadataKey))
|
|
return false;
|
|
if (metadataMap.size > 0)
|
|
return true;
|
|
var targetMetadata = Metadata.get(target);
|
|
targetMetadata.delete(propertyKey);
|
|
if (targetMetadata.size > 0)
|
|
return true;
|
|
Metadata.delete(target);
|
|
return true;
|
|
}
|
|
exporter("deleteMetadata", deleteMetadata);
|
|
function DecorateConstructor(decorators, target) {
|
|
for (var i = decorators.length - 1; i >= 0; --i) {
|
|
var decorator = decorators[i];
|
|
var decorated = decorator(target);
|
|
if (!IsUndefined(decorated) && !IsNull(decorated)) {
|
|
if (!IsConstructor(decorated))
|
|
throw new TypeError();
|
|
target = decorated;
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function DecorateProperty(decorators, target, propertyKey, descriptor) {
|
|
for (var i = decorators.length - 1; i >= 0; --i) {
|
|
var decorator = decorators[i];
|
|
var decorated = decorator(target, propertyKey, descriptor);
|
|
if (!IsUndefined(decorated) && !IsNull(decorated)) {
|
|
if (!IsObject(decorated))
|
|
throw new TypeError();
|
|
descriptor = decorated;
|
|
}
|
|
}
|
|
return descriptor;
|
|
}
|
|
function GetOrCreateMetadataMap(O, P, Create) {
|
|
var targetMetadata = Metadata.get(O);
|
|
if (IsUndefined(targetMetadata)) {
|
|
if (!Create)
|
|
return undefined;
|
|
targetMetadata = new _Map();
|
|
Metadata.set(O, targetMetadata);
|
|
}
|
|
var metadataMap = targetMetadata.get(P);
|
|
if (IsUndefined(metadataMap)) {
|
|
if (!Create)
|
|
return undefined;
|
|
metadataMap = new _Map();
|
|
targetMetadata.set(P, metadataMap);
|
|
}
|
|
return metadataMap;
|
|
}
|
|
// 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata
|
|
function OrdinaryHasMetadata(MetadataKey, O, P) {
|
|
var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
|
|
if (hasOwn)
|
|
return true;
|
|
var parent = OrdinaryGetPrototypeOf(O);
|
|
if (!IsNull(parent))
|
|
return OrdinaryHasMetadata(MetadataKey, parent, P);
|
|
return false;
|
|
}
|
|
// 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata
|
|
function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
|
|
if (IsUndefined(metadataMap))
|
|
return false;
|
|
return ToBoolean(metadataMap.has(MetadataKey));
|
|
}
|
|
// 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata
|
|
function OrdinaryGetMetadata(MetadataKey, O, P) {
|
|
var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
|
|
if (hasOwn)
|
|
return OrdinaryGetOwnMetadata(MetadataKey, O, P);
|
|
var parent = OrdinaryGetPrototypeOf(O);
|
|
if (!IsNull(parent))
|
|
return OrdinaryGetMetadata(MetadataKey, parent, P);
|
|
return undefined;
|
|
}
|
|
// 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata
|
|
function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
|
|
if (IsUndefined(metadataMap))
|
|
return undefined;
|
|
return metadataMap.get(MetadataKey);
|
|
}
|
|
// 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata
|
|
function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
|
|
var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);
|
|
metadataMap.set(MetadataKey, MetadataValue);
|
|
}
|
|
// 3.1.6.1 OrdinaryMetadataKeys(O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys
|
|
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;
|
|
}
|
|
// 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)
|
|
// https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys
|
|
function OrdinaryOwnMetadataKeys(O, P) {
|
|
var keys = [];
|
|
var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
|
|
if (IsUndefined(metadataMap))
|
|
return keys;
|
|
var keysObj = metadataMap.keys();
|
|
var iterator = GetIterator(keysObj);
|
|
var k = 0;
|
|
while (true) {
|
|
var next = IteratorStep(iterator);
|
|
if (!next) {
|
|
keys.length = k;
|
|
return keys;
|
|
}
|
|
var nextValue = IteratorValue(next);
|
|
try {
|
|
keys[k] = nextValue;
|
|
}
|
|
catch (e) {
|
|
try {
|
|
IteratorClose(iterator);
|
|
}
|
|
finally {
|
|
throw e;
|
|
}
|
|
}
|
|
k++;
|
|
}
|
|
}
|
|
// 6 ECMAScript Data Typ0es and Values
|
|
// https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
|
|
function Type(x) {
|
|
if (x === null)
|
|
return 1 /* Null */;
|
|
switch (typeof x) {
|
|
case "undefined": return 0 /* Undefined */;
|
|
case "boolean": return 2 /* Boolean */;
|
|
case "string": return 3 /* String */;
|
|
case "symbol": return 4 /* Symbol */;
|
|
case "number": return 5 /* Number */;
|
|
case "object": return x === null ? 1 /* Null */ : 6 /* Object */;
|
|
default: return 6 /* Object */;
|
|
}
|
|
}
|
|
// 6.1.1 The Undefined Type
|
|
// https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type
|
|
function IsUndefined(x) {
|
|
return x === undefined;
|
|
}
|
|
// 6.1.2 The Null Type
|
|
// https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type
|
|
function IsNull(x) {
|
|
return x === null;
|
|
}
|
|
// 6.1.5 The Symbol Type
|
|
// https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type
|
|
function IsSymbol(x) {
|
|
return typeof x === "symbol";
|
|
}
|
|
// 6.1.7 The Object Type
|
|
// https://tc39.github.io/ecma262/#sec-object-type
|
|
function IsObject(x) {
|
|
return typeof x === "object" ? x !== null : typeof x === "function";
|
|
}
|
|
// 7.1 Type Conversion
|
|
// https://tc39.github.io/ecma262/#sec-type-conversion
|
|
// 7.1.1 ToPrimitive(input [, PreferredType])
|
|
// https://tc39.github.io/ecma262/#sec-toprimitive
|
|
function ToPrimitive(input, PreferredType) {
|
|
switch (Type(input)) {
|
|
case 0 /* Undefined */: return input;
|
|
case 1 /* Null */: return input;
|
|
case 2 /* Boolean */: return input;
|
|
case 3 /* String */: return input;
|
|
case 4 /* Symbol */: return input;
|
|
case 5 /* Number */: return input;
|
|
}
|
|
var hint = PreferredType === 3 /* String */ ? "string" : PreferredType === 5 /* Number */ ? "number" : "default";
|
|
var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
|
|
if (exoticToPrim !== undefined) {
|
|
var result = exoticToPrim.call(input, hint);
|
|
if (IsObject(result))
|
|
throw new TypeError();
|
|
return result;
|
|
}
|
|
return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
|
|
}
|
|
// 7.1.1.1 OrdinaryToPrimitive(O, hint)
|
|
// https://tc39.github.io/ecma262/#sec-ordinarytoprimitive
|
|
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();
|
|
}
|
|
// 7.1.2 ToBoolean(argument)
|
|
// https://tc39.github.io/ecma262/2016/#sec-toboolean
|
|
function ToBoolean(argument) {
|
|
return !!argument;
|
|
}
|
|
// 7.1.12 ToString(argument)
|
|
// https://tc39.github.io/ecma262/#sec-tostring
|
|
function ToString(argument) {
|
|
return "" + argument;
|
|
}
|
|
// 7.1.14 ToPropertyKey(argument)
|
|
// https://tc39.github.io/ecma262/#sec-topropertykey
|
|
function ToPropertyKey(argument) {
|
|
var key = ToPrimitive(argument, 3 /* String */);
|
|
if (IsSymbol(key))
|
|
return key;
|
|
return ToString(key);
|
|
}
|
|
// 7.2 Testing and Comparison Operations
|
|
// https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations
|
|
// 7.2.2 IsArray(argument)
|
|
// https://tc39.github.io/ecma262/#sec-isarray
|
|
function IsArray(argument) {
|
|
return Array.isArray
|
|
? Array.isArray(argument)
|
|
: argument instanceof Object
|
|
? argument instanceof Array
|
|
: Object.prototype.toString.call(argument) === "[object Array]";
|
|
}
|
|
// 7.2.3 IsCallable(argument)
|
|
// https://tc39.github.io/ecma262/#sec-iscallable
|
|
function IsCallable(argument) {
|
|
// NOTE: This is an approximation as we cannot check for [[Call]] internal method.
|
|
return typeof argument === "function";
|
|
}
|
|
// 7.2.4 IsConstructor(argument)
|
|
// https://tc39.github.io/ecma262/#sec-isconstructor
|
|
function IsConstructor(argument) {
|
|
// NOTE: This is an approximation as we cannot check for [[Construct]] internal method.
|
|
return typeof argument === "function";
|
|
}
|
|
// 7.2.7 IsPropertyKey(argument)
|
|
// https://tc39.github.io/ecma262/#sec-ispropertykey
|
|
function IsPropertyKey(argument) {
|
|
switch (Type(argument)) {
|
|
case 3 /* String */: return true;
|
|
case 4 /* Symbol */: return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
// 7.3 Operations on Objects
|
|
// https://tc39.github.io/ecma262/#sec-operations-on-objects
|
|
// 7.3.9 GetMethod(V, P)
|
|
// https://tc39.github.io/ecma262/#sec-getmethod
|
|
function GetMethod(V, P) {
|
|
var func = V[P];
|
|
if (func === undefined || func === null)
|
|
return undefined;
|
|
if (!IsCallable(func))
|
|
throw new TypeError();
|
|
return func;
|
|
}
|
|
// 7.4 Operations on Iterator Objects
|
|
// https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects
|
|
function GetIterator(obj) {
|
|
var method = GetMethod(obj, iteratorSymbol);
|
|
if (!IsCallable(method))
|
|
throw new TypeError(); // from Call
|
|
var iterator = method.call(obj);
|
|
if (!IsObject(iterator))
|
|
throw new TypeError();
|
|
return iterator;
|
|
}
|
|
// 7.4.4 IteratorValue(iterResult)
|
|
// https://tc39.github.io/ecma262/2016/#sec-iteratorvalue
|
|
function IteratorValue(iterResult) {
|
|
return iterResult.value;
|
|
}
|
|
// 7.4.5 IteratorStep(iterator)
|
|
// https://tc39.github.io/ecma262/#sec-iteratorstep
|
|
function IteratorStep(iterator) {
|
|
var result = iterator.next();
|
|
return result.done ? false : result;
|
|
}
|
|
// 7.4.6 IteratorClose(iterator, completion)
|
|
// https://tc39.github.io/ecma262/#sec-iteratorclose
|
|
function IteratorClose(iterator) {
|
|
var f = iterator["return"];
|
|
if (f)
|
|
f.call(iterator);
|
|
}
|
|
// 9.1 Ordinary Object Internal Methods and Internal Slots
|
|
// https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots
|
|
// 9.1.1.1 OrdinaryGetPrototypeOf(O)
|
|
// https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof
|
|
function OrdinaryGetPrototypeOf(O) {
|
|
var proto = Object.getPrototypeOf(O);
|
|
if (typeof O !== "function" || O === functionPrototype)
|
|
return proto;
|
|
// TypeScript doesn't set __proto__ in ES5, as it's non-standard.
|
|
// Try to determine the superclass constructor. Compatible implementations
|
|
// must either set __proto__ on a subclass constructor to the superclass constructor,
|
|
// or ensure each class has a valid `constructor` property on its prototype that
|
|
// points back to the constructor.
|
|
// If this is not the same as Function.[[Prototype]], then this is definately inherited.
|
|
// This is the case when in ES6 or when using __proto__ in a compatible browser.
|
|
if (proto !== functionPrototype)
|
|
return proto;
|
|
// If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.
|
|
var prototype = O.prototype;
|
|
var prototypeProto = prototype && Object.getPrototypeOf(prototype);
|
|
if (prototypeProto == null || prototypeProto === Object.prototype)
|
|
return proto;
|
|
// If the constructor was not a function, then we cannot determine the heritage.
|
|
var constructor = prototypeProto.constructor;
|
|
if (typeof constructor !== "function")
|
|
return proto;
|
|
// If we have some kind of self-reference, then we cannot determine the heritage.
|
|
if (constructor === O)
|
|
return proto;
|
|
// we have a pretty good guess at the heritage.
|
|
return constructor;
|
|
}
|
|
// naive Map shim
|
|
function CreateMapPolyfill() {
|
|
var cacheSentinel = {};
|
|
var arraySentinel = [];
|
|
var MapIterator = /** @class */ (function () {
|
|
function MapIterator(keys, values, selector) {
|
|
this._index = 0;
|
|
this._keys = keys;
|
|
this._values = values;
|
|
this._selector = selector;
|
|
}
|
|
MapIterator.prototype["@@iterator"] = function () { return this; };
|
|
MapIterator.prototype[iteratorSymbol] = function () { return this; };
|
|
MapIterator.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: undefined, done: true };
|
|
};
|
|
MapIterator.prototype.throw = function (error) {
|
|
if (this._index >= 0) {
|
|
this._index = -1;
|
|
this._keys = arraySentinel;
|
|
this._values = arraySentinel;
|
|
}
|
|
throw error;
|
|
};
|
|
MapIterator.prototype.return = function (value) {
|
|
if (this._index >= 0) {
|
|
this._index = -1;
|
|
this._keys = arraySentinel;
|
|
this._values = arraySentinel;
|
|
}
|
|
return { value: value, done: true };
|
|
};
|
|
return MapIterator;
|
|
}());
|
|
return /** @class */ (function () {
|
|
function Map() {
|
|
this._keys = [];
|
|
this._values = [];
|
|
this._cacheKey = cacheSentinel;
|
|
this._cacheIndex = -2;
|
|
}
|
|
Object.defineProperty(Map.prototype, "size", {
|
|
get: function () { return this._keys.length; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };
|
|
Map.prototype.get = function (key) {
|
|
var index = this._find(key, /*insert*/ false);
|
|
return index >= 0 ? this._values[index] : undefined;
|
|
};
|
|
Map.prototype.set = function (key, value) {
|
|
var index = this._find(key, /*insert*/ true);
|
|
this._values[index] = value;
|
|
return this;
|
|
};
|
|
Map.prototype.delete = function (key) {
|
|
var index = this._find(key, /*insert*/ false);
|
|
if (index >= 0) {
|
|
var size = this._keys.length;
|
|
for (var i = index + 1; i < size; i++) {
|
|
this._keys[i - 1] = this._keys[i];
|
|
this._values[i - 1] = this._values[i];
|
|
}
|
|
this._keys.length--;
|
|
this._values.length--;
|
|
if (key === this._cacheKey) {
|
|
this._cacheKey = cacheSentinel;
|
|
this._cacheIndex = -2;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
Map.prototype.clear = function () {
|
|
this._keys.length = 0;
|
|
this._values.length = 0;
|
|
this._cacheKey = cacheSentinel;
|
|
this._cacheIndex = -2;
|
|
};
|
|
Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };
|
|
Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };
|
|
Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };
|
|
Map.prototype["@@iterator"] = function () { return this.entries(); };
|
|
Map.prototype[iteratorSymbol] = function () { return this.entries(); };
|
|
Map.prototype._find = function (key, insert) {
|
|
if (this._cacheKey !== key) {
|
|
this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
|
|
}
|
|
if (this._cacheIndex < 0 && insert) {
|
|
this._cacheIndex = this._keys.length;
|
|
this._keys.push(key);
|
|
this._values.push(undefined);
|
|
}
|
|
return this._cacheIndex;
|
|
};
|
|
return Map;
|
|
}());
|
|
function getKey(key, _) {
|
|
return key;
|
|
}
|
|
function getValue(_, value) {
|
|
return value;
|
|
}
|
|
function getEntry(key, value) {
|
|
return [key, value];
|
|
}
|
|
}
|
|
// naive Set shim
|
|
function CreateSetPolyfill() {
|
|
return /** @class */ (function () {
|
|
function Set() {
|
|
this._map = new _Map();
|
|
}
|
|
Object.defineProperty(Set.prototype, "size", {
|
|
get: function () { return this._map.size; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Set.prototype.has = function (value) { return this._map.has(value); };
|
|
Set.prototype.add = function (value) { return this._map.set(value, value), this; };
|
|
Set.prototype.delete = function (value) { return this._map.delete(value); };
|
|
Set.prototype.clear = function () { this._map.clear(); };
|
|
Set.prototype.keys = function () { return this._map.keys(); };
|
|
Set.prototype.values = function () { return this._map.values(); };
|
|
Set.prototype.entries = function () { return this._map.entries(); };
|
|
Set.prototype["@@iterator"] = function () { return this.keys(); };
|
|
Set.prototype[iteratorSymbol] = function () { return this.keys(); };
|
|
return Set;
|
|
}());
|
|
}
|
|
// naive WeakMap shim
|
|
function CreateWeakMapPolyfill() {
|
|
var UUID_SIZE = 16;
|
|
var keys = HashMap.create();
|
|
var rootKey = CreateUniqueKey();
|
|
return /** @class */ (function () {
|
|
function WeakMap() {
|
|
this._key = CreateUniqueKey();
|
|
}
|
|
WeakMap.prototype.has = function (target) {
|
|
var table = GetOrCreateWeakMapTable(target, /*create*/ false);
|
|
return table !== undefined ? HashMap.has(table, this._key) : false;
|
|
};
|
|
WeakMap.prototype.get = function (target) {
|
|
var table = GetOrCreateWeakMapTable(target, /*create*/ false);
|
|
return table !== undefined ? HashMap.get(table, this._key) : undefined;
|
|
};
|
|
WeakMap.prototype.set = function (target, value) {
|
|
var table = GetOrCreateWeakMapTable(target, /*create*/ true);
|
|
table[this._key] = value;
|
|
return this;
|
|
};
|
|
WeakMap.prototype.delete = function (target) {
|
|
var table = GetOrCreateWeakMapTable(target, /*create*/ false);
|
|
return table !== undefined ? delete table[this._key] : false;
|
|
};
|
|
WeakMap.prototype.clear = function () {
|
|
// NOTE: not a real clear, just makes the previous data unreachable
|
|
this._key = CreateUniqueKey();
|
|
};
|
|
return WeakMap;
|
|
}());
|
|
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 undefined;
|
|
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() * 0xff | 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);
|
|
// mark as random - RFC 4122 § 4.4
|
|
data[6] = data[6] & 0x4f | 0x40;
|
|
data[8] = data[8] & 0xbf | 0x80;
|
|
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;
|
|
}
|
|
}
|
|
// uses a heuristic used by v8 and chakra to force an object into dictionary mode.
|
|
function MakeDictionary(obj) {
|
|
obj.__ = undefined;
|
|
delete obj.__;
|
|
return obj;
|
|
}
|
|
});
|
|
})(Reflect || (Reflect = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/lib/core/ipc/MainIPC.ts":
|
|
/*!*************************************!*\
|
|
!*** ./src/lib/core/ipc/MainIPC.ts ***!
|
|
\*************************************/
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* eslint-disable prefer-rest-params */
|
|
Object.defineProperty(exports, "__esModule", ({
|
|
value: true
|
|
}));
|
|
Object.defineProperty(exports, "default", ({
|
|
enumerable: true,
|
|
get: function() {
|
|
return MainIPC;
|
|
}
|
|
}));
|
|
var _tsyringe = __webpack_require__(/*! tsyringe */ "./node_modules/tsyringe/dist/esm5/index.js");
|
|
var _global = __webpack_require__(/*! ../service/util/global */ "./src/lib/core/service/util/global.ts");
|
|
function _arrayLikeToArray(arr, len) {
|
|
if (len == null || len > arr.length) len = arr.length;
|
|
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
|
|
return arr2;
|
|
}
|
|
function _arrayWithoutHoles(arr) {
|
|
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
|
|
}
|
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
|
try {
|
|
var info = gen[key](arg);
|
|
var value = info.value;
|
|
} catch (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
if (info.done) {
|
|
resolve(value);
|
|
} else {
|
|
Promise.resolve(value).then(_next, _throw);
|
|
}
|
|
}
|
|
function _asyncToGenerator(fn) {
|
|
return function() {
|
|
var self = this, args = arguments;
|
|
return new Promise(function(resolve, reject) {
|
|
var gen = fn.apply(self, args);
|
|
function _next(value) {
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
|
|
}
|
|
function _throw(err) {
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
|
|
}
|
|
_next(undefined);
|
|
});
|
|
};
|
|
}
|
|
function _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
function _iterableToArray(iter) {
|
|
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
|
|
}
|
|
function _nonIterableSpread() {
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
function _toConsumableArray(arr) {
|
|
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
|
|
}
|
|
function _unsupportedIterableToArray(o, minLen) {
|
|
if (!o) return;
|
|
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
if (n === "Map" || n === "Set") return Array.from(n);
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
|
}
|
|
var __decorate = (void 0) && (void 0).__decorate || function(decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
};
|
|
var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
|
|
var f, y, t, g, _ = {
|
|
label: 0,
|
|
sent: function() {
|
|
if (t[0] & 1) throw t[1];
|
|
return t[1];
|
|
},
|
|
trys: [],
|
|
ops: []
|
|
};
|
|
return g = {
|
|
next: verb(0),
|
|
"throw": verb(1),
|
|
"return": verb(2)
|
|
}, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
|
|
return this;
|
|
}), g;
|
|
function verb(n) {
|
|
return function(v) {
|
|
return step([
|
|
n,
|
|
v
|
|
]);
|
|
};
|
|
}
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while(_)try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [
|
|
op[0] & 2,
|
|
t.value
|
|
];
|
|
switch(op[0]){
|
|
case 0:
|
|
case 1:
|
|
t = op;
|
|
break;
|
|
case 4:
|
|
_.label++;
|
|
return {
|
|
value: op[1],
|
|
done: false
|
|
};
|
|
case 5:
|
|
_.label++;
|
|
y = op[1];
|
|
op = [
|
|
0
|
|
];
|
|
continue;
|
|
case 7:
|
|
op = _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
_ = 0;
|
|
continue;
|
|
}
|
|
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
_.label = op[1];
|
|
break;
|
|
}
|
|
if (op[0] === 6 && _.label < t[1]) {
|
|
_.label = t[1];
|
|
t = op;
|
|
break;
|
|
}
|
|
if (t && _.label < t[2]) {
|
|
_.label = t[2];
|
|
_.ops.push(op);
|
|
break;
|
|
}
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) {
|
|
op = [
|
|
6,
|
|
e
|
|
];
|
|
y = 0;
|
|
} finally{
|
|
f = t = 0;
|
|
}
|
|
if (op[0] & 5) throw op[1];
|
|
return {
|
|
value: op[0] ? op[1] : void 0,
|
|
done: true
|
|
};
|
|
}
|
|
};
|
|
var MainIPC = /*#__PURE__*/ function() {
|
|
"use strict";
|
|
function MainIPC() {
|
|
_classCallCheck(this, MainIPC);
|
|
}
|
|
var _proto = MainIPC.prototype;
|
|
_proto.executeMainScript = function executeMainScript(method) {
|
|
for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
return _asyncToGenerator(function() {
|
|
var _Editor_Message;
|
|
return __generator(this, function(_state) {
|
|
switch(_state.label){
|
|
case 0:
|
|
return [
|
|
4,
|
|
(_Editor_Message = Editor.Message).request.apply(_Editor_Message, [
|
|
_global.MainName,
|
|
method
|
|
].concat(_toConsumableArray(args)))
|
|
];
|
|
case 1:
|
|
return [
|
|
2,
|
|
_state.sent()
|
|
];
|
|
}
|
|
});
|
|
})();
|
|
};
|
|
_proto.toggle = function toggle() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"toggle"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.enableChanged = function enableChanged() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"enable-changed"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getEnable = function getEnable() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-enable"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.openPanel = function openPanel() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"open-panel"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.previewBy = function previewBy(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"preview-by"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.scan = function scan(scanOptions) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"scan"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.uninstall = function uninstall() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"uninstall"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.readConfig = function readConfig() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"read-config"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getIndexData = function getIndexData() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-index-data"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getLocalLanguage = function getLocalLanguage() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-local-language"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getTranslateData = function getTranslateData(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-translate-data"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getTranslateDataObject = function getTranslateDataObject(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-translate-data-object"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.saveTranslateData = function saveTranslateData(locale, translateItems, mergeOption) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"save-translate-data"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.clearTranslateData = function clearTranslateData() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"clear-translate-data"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.setLocalLanguageLocale = function setLocalLanguageLocale(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"set-local-language-locale"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.setLanguageConfig = function setLanguageConfig(languageConfig) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"set-language-config"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getLanguageConfig = function getLanguageConfig(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-language-config"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getAllLanguageConfigs = function getAllLanguageConfigs() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-all-language-configs"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.addTargetLanguage = function addTargetLanguage(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"add-target-language"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.removeTargetLanguage = function removeTargetLanguage(locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"remove-target-language"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getTranslateProviders = function getTranslateProviders() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-translate-providers"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getTranslateProviderSupportedLanguages = function getTranslateProviderSupportedLanguages(provider) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-translate-provider-supported-languages"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getCurrentTranslateProvider = function getCurrentTranslateProvider() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-current-translate-provider"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getTranslateProvider = function getTranslateProvider(configType) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-translate-provider"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.setCurrentTranslateProvider = function setCurrentTranslateProvider(providerConfig) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"set-current-translate-provider"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.clearTranslateProvider = function clearTranslateProvider() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"clear-translate-provider"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.changeValue = function changeValue(locale, key, value) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"change-value"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getScanOptions = function getScanOptions() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-scan-options"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.autoTranslate = function autoTranslate(toTag) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"auto-translate"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.importMediaFiles = function importMediaFiles(toTag, fromPattern, toPattern) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"import-media-files"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.compile = function compile(locales) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"compile"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.addAssociation = function addAssociation(key, association) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"add-association"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.removeAssociation = function removeAssociation(key, association) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"remove-association"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getResourceList = function getResourceList() {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-resource-list"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.getResourceBundle = function getResourceBundle(locals) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"get-resource-bundle"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.importTranslateFile = function importTranslateFile(filePath, translateFileType, locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"import-translate-file"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
_proto.exportTranslateFile = function exportTranslateFile(filePath, translateFileType, locale) {
|
|
var _this = this, _arguments = arguments;
|
|
return _asyncToGenerator(function() {
|
|
return __generator(this, function(_state) {
|
|
return [
|
|
2,
|
|
_this.executeMainScript.apply(_this, [
|
|
"export-translate-file"
|
|
].concat(_toConsumableArray(_arguments)))
|
|
];
|
|
});
|
|
})();
|
|
};
|
|
return MainIPC;
|
|
}();
|
|
MainIPC = __decorate([
|
|
(0, _tsyringe.singleton)()
|
|
], MainIPC);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/lib/core/service/util/global.ts":
|
|
/*!*********************************************!*\
|
|
!*** ./src/lib/core/service/util/global.ts ***!
|
|
\*********************************************/
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", ({
|
|
value: true
|
|
}));
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
MainName: function() {
|
|
return MainName;
|
|
},
|
|
ProjectAssetPath: function() {
|
|
return ProjectAssetPath;
|
|
},
|
|
RuntimeBundleName: function() {
|
|
return RuntimeBundleName;
|
|
},
|
|
resourceListPath: function() {
|
|
return resourceListPath;
|
|
},
|
|
resourceBundlePath: function() {
|
|
return resourceBundlePath;
|
|
},
|
|
DEFAULT_NAMESPACE: function() {
|
|
return DEFAULT_NAMESPACE;
|
|
},
|
|
ASSET_NAMESPACE: function() {
|
|
return ASSET_NAMESPACE;
|
|
},
|
|
ALLOW_NAMESPACE: function() {
|
|
return ALLOW_NAMESPACE;
|
|
}
|
|
});
|
|
var _path = __webpack_require__(/*! path */ "path");
|
|
var MainName = "localization-editor";
|
|
var ProjectAssetPath = (0, _path.join)(Editor.Project.path, "assets");
|
|
var RuntimeBundleName = "l10n";
|
|
var resourceListPath = "resource-list";
|
|
var resourceBundlePath = "resource-bundle";
|
|
var DEFAULT_NAMESPACE = "translation";
|
|
var ASSET_NAMESPACE = "asset";
|
|
var ALLOW_NAMESPACE = [
|
|
DEFAULT_NAMESPACE,
|
|
ASSET_NAMESPACE
|
|
];
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/lib/server/server.ts":
|
|
/*!**********************************!*\
|
|
!*** ./src/lib/server/server.ts ***!
|
|
\**********************************/
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", ({
|
|
value: true
|
|
}));
|
|
Object.defineProperty(exports, "get", ({
|
|
enumerable: true,
|
|
get: function() {
|
|
return get;
|
|
}
|
|
}));
|
|
__webpack_require__(/*! reflect-metadata */ "./node_modules/reflect-metadata/Reflect.js");
|
|
var _global = __webpack_require__(/*! ../core/service/util/global */ "./src/lib/core/service/util/global.ts");
|
|
var _tsyringe = __webpack_require__(/*! tsyringe */ "./node_modules/tsyringe/dist/esm5/index.js");
|
|
var _mainIPC = /*#__PURE__*/ _interopRequireDefault(__webpack_require__(/*! ../core/ipc/MainIPC */ "./src/lib/core/ipc/MainIPC.ts"));
|
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
|
try {
|
|
var info = gen[key](arg);
|
|
var value = info.value;
|
|
} catch (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
if (info.done) {
|
|
resolve(value);
|
|
} else {
|
|
Promise.resolve(value).then(_next, _throw);
|
|
}
|
|
}
|
|
function _asyncToGenerator(fn) {
|
|
return function() {
|
|
var self = this, args = arguments;
|
|
return new Promise(function(resolve, reject) {
|
|
var gen = fn.apply(self, args);
|
|
function _next(value) {
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
|
|
}
|
|
function _throw(err) {
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
|
|
}
|
|
_next(undefined);
|
|
});
|
|
};
|
|
}
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : {
|
|
default: obj
|
|
};
|
|
}
|
|
var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
|
|
var f, y, t, g, _ = {
|
|
label: 0,
|
|
sent: function() {
|
|
if (t[0] & 1) throw t[1];
|
|
return t[1];
|
|
},
|
|
trys: [],
|
|
ops: []
|
|
};
|
|
return g = {
|
|
next: verb(0),
|
|
"throw": verb(1),
|
|
"return": verb(2)
|
|
}, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
|
|
return this;
|
|
}), g;
|
|
function verb(n) {
|
|
return function(v) {
|
|
return step([
|
|
n,
|
|
v
|
|
]);
|
|
};
|
|
}
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while(_)try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [
|
|
op[0] & 2,
|
|
t.value
|
|
];
|
|
switch(op[0]){
|
|
case 0:
|
|
case 1:
|
|
t = op;
|
|
break;
|
|
case 4:
|
|
_.label++;
|
|
return {
|
|
value: op[1],
|
|
done: false
|
|
};
|
|
case 5:
|
|
_.label++;
|
|
y = op[1];
|
|
op = [
|
|
0
|
|
];
|
|
continue;
|
|
case 7:
|
|
op = _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
_ = 0;
|
|
continue;
|
|
}
|
|
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
_.label = op[1];
|
|
break;
|
|
}
|
|
if (op[0] === 6 && _.label < t[1]) {
|
|
_.label = t[1];
|
|
t = op;
|
|
break;
|
|
}
|
|
if (t && _.label < t[2]) {
|
|
_.label = t[2];
|
|
_.ops.push(op);
|
|
break;
|
|
}
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) {
|
|
op = [
|
|
6,
|
|
e
|
|
];
|
|
y = 0;
|
|
} finally{
|
|
f = t = 0;
|
|
}
|
|
if (op[0] & 5) throw op[1];
|
|
return {
|
|
value: op[0] ? op[1] : void 0,
|
|
done: true
|
|
};
|
|
}
|
|
};
|
|
var mainIPC = _tsyringe.container.resolve(_mainIPC.default);
|
|
var get = [
|
|
{
|
|
url: "/".concat(_global.MainName, "/resource-list"),
|
|
handle: function handle(req, res, next) {
|
|
return _asyncToGenerator(function() {
|
|
var resourceList;
|
|
return __generator(this, function(_state) {
|
|
switch(_state.label){
|
|
case 0:
|
|
console.debug("request resource-list");
|
|
return [
|
|
4,
|
|
mainIPC.getResourceList()
|
|
];
|
|
case 1:
|
|
resourceList = _state.sent();
|
|
console.debug(resourceList);
|
|
res.json(resourceList);
|
|
return [
|
|
2
|
|
];
|
|
}
|
|
});
|
|
})();
|
|
}
|
|
},
|
|
{
|
|
url: "/".concat(_global.MainName, "/resource-bundle"),
|
|
handle: function handle(req, res, next) {
|
|
return _asyncToGenerator(function() {
|
|
var resourceBundle;
|
|
return __generator(this, function(_state) {
|
|
switch(_state.label){
|
|
case 0:
|
|
console.debug("request resource-bundle");
|
|
return [
|
|
4,
|
|
mainIPC.getResourceBundle([])
|
|
];
|
|
case 1:
|
|
resourceBundle = _state.sent();
|
|
console.debug(resourceBundle);
|
|
res.json(resourceBundle);
|
|
return [
|
|
2
|
|
];
|
|
}
|
|
});
|
|
})();
|
|
}
|
|
}
|
|
];
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tslib/tslib.es6.js":
|
|
/*!*****************************************!*\
|
|
!*** ./node_modules/tslib/tslib.es6.js ***!
|
|
\*****************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "__assign": () => (/* binding */ __assign),
|
|
/* harmony export */ "__asyncDelegator": () => (/* binding */ __asyncDelegator),
|
|
/* harmony export */ "__asyncGenerator": () => (/* binding */ __asyncGenerator),
|
|
/* harmony export */ "__asyncValues": () => (/* binding */ __asyncValues),
|
|
/* harmony export */ "__await": () => (/* binding */ __await),
|
|
/* harmony export */ "__awaiter": () => (/* binding */ __awaiter),
|
|
/* harmony export */ "__classPrivateFieldGet": () => (/* binding */ __classPrivateFieldGet),
|
|
/* harmony export */ "__classPrivateFieldSet": () => (/* binding */ __classPrivateFieldSet),
|
|
/* harmony export */ "__createBinding": () => (/* binding */ __createBinding),
|
|
/* harmony export */ "__decorate": () => (/* binding */ __decorate),
|
|
/* harmony export */ "__exportStar": () => (/* binding */ __exportStar),
|
|
/* harmony export */ "__extends": () => (/* binding */ __extends),
|
|
/* harmony export */ "__generator": () => (/* binding */ __generator),
|
|
/* harmony export */ "__importDefault": () => (/* binding */ __importDefault),
|
|
/* harmony export */ "__importStar": () => (/* binding */ __importStar),
|
|
/* harmony export */ "__makeTemplateObject": () => (/* binding */ __makeTemplateObject),
|
|
/* harmony export */ "__metadata": () => (/* binding */ __metadata),
|
|
/* harmony export */ "__param": () => (/* binding */ __param),
|
|
/* harmony export */ "__read": () => (/* binding */ __read),
|
|
/* harmony export */ "__rest": () => (/* binding */ __rest),
|
|
/* harmony export */ "__spread": () => (/* binding */ __spread),
|
|
/* harmony export */ "__spreadArrays": () => (/* binding */ __spreadArrays),
|
|
/* harmony export */ "__values": () => (/* binding */ __values)
|
|
/* harmony export */ });
|
|
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
PERFORMANCE OF THIS SOFTWARE.
|
|
***************************************************************************** */
|
|
/* global Reflect, Promise */
|
|
|
|
var extendStatics = function(d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
|
|
function __extends(d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
}
|
|
|
|
var __assign = function() {
|
|
__assign = Object.assign || function __assign(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
|
}
|
|
return t;
|
|
}
|
|
return __assign.apply(this, arguments);
|
|
}
|
|
|
|
function __rest(s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
|
t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
|
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
|
t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
}
|
|
|
|
function __decorate(decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
}
|
|
|
|
function __param(paramIndex, decorator) {
|
|
return function (target, key) { decorator(target, key, paramIndex); }
|
|
}
|
|
|
|
function __metadata(metadataKey, metadataValue) {
|
|
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
|
|
}
|
|
|
|
function __awaiter(thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
}
|
|
|
|
function __generator(thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (_) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
}
|
|
|
|
function __createBinding(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}
|
|
|
|
function __exportStar(m, exports) {
|
|
for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
|
|
}
|
|
|
|
function __values(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
}
|
|
|
|
function __read(o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
}
|
|
|
|
function __spread() {
|
|
for (var ar = [], i = 0; i < arguments.length; i++)
|
|
ar = ar.concat(__read(arguments[i]));
|
|
return ar;
|
|
}
|
|
|
|
function __spreadArrays() {
|
|
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
|
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
|
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
|
r[k] = a[j];
|
|
return r;
|
|
};
|
|
|
|
function __await(v) {
|
|
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
|
}
|
|
|
|
function __asyncGenerator(thisArg, _arguments, generator) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
|
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
|
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
|
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
|
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
|
function fulfill(value) { resume("next", value); }
|
|
function reject(value) { resume("throw", value); }
|
|
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
|
}
|
|
|
|
function __asyncDelegator(o) {
|
|
var i, p;
|
|
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
|
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
|
|
}
|
|
|
|
function __asyncValues(o) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var m = o[Symbol.asyncIterator], i;
|
|
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
|
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
|
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
|
}
|
|
|
|
function __makeTemplateObject(cooked, raw) {
|
|
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
|
return cooked;
|
|
};
|
|
|
|
function __importStar(mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
|
result.default = mod;
|
|
return result;
|
|
}
|
|
|
|
function __importDefault(mod) {
|
|
return (mod && mod.__esModule) ? mod : { default: mod };
|
|
}
|
|
|
|
function __classPrivateFieldGet(receiver, privateMap) {
|
|
if (!privateMap.has(receiver)) {
|
|
throw new TypeError("attempted to get private field on non-instance");
|
|
}
|
|
return privateMap.get(receiver);
|
|
}
|
|
|
|
function __classPrivateFieldSet(receiver, privateMap, value) {
|
|
if (!privateMap.has(receiver)) {
|
|
throw new TypeError("attempted to set private field on non-instance");
|
|
}
|
|
privateMap.set(receiver, value);
|
|
return value;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/auto-injectable.js":
|
|
/*!***********************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/auto-injectable.js ***!
|
|
\***********************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
/* harmony import */ var _reflection_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../reflection-helpers */ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js");
|
|
/* harmony import */ var _dependency_container__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../dependency-container */ "./node_modules/tsyringe/dist/esm5/dependency-container.js");
|
|
/* harmony import */ var _providers_injection_token__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../providers/injection-token */ "./node_modules/tsyringe/dist/esm5/providers/injection-token.js");
|
|
/* harmony import */ var _error_helpers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../error-helpers */ "./node_modules/tsyringe/dist/esm5/error-helpers.js");
|
|
|
|
|
|
|
|
|
|
|
|
function autoInjectable() {
|
|
return function (target) {
|
|
var paramInfo = (0,_reflection_helpers__WEBPACK_IMPORTED_MODULE_0__.getParamInfo)(target);
|
|
return (function (_super) {
|
|
(0,tslib__WEBPACK_IMPORTED_MODULE_4__.__extends)(class_1, _super);
|
|
function class_1() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
return _super.apply(this, (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)(args.concat(paramInfo.slice(args.length).map(function (type, index) {
|
|
var _a, _b, _c;
|
|
try {
|
|
if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isTokenDescriptor)(type)) {
|
|
if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isTransformDescriptor)(type)) {
|
|
return type.multiple
|
|
? (_a = _dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type.transform)).transform.apply(_a, (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)([_dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolveAll(type.token)], type.transformArgs)) : (_b = _dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type.transform)).transform.apply(_b, (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)([_dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type.token)], type.transformArgs));
|
|
}
|
|
else {
|
|
return type.multiple
|
|
? _dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolveAll(type.token)
|
|
: _dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type.token);
|
|
}
|
|
}
|
|
else if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isTransformDescriptor)(type)) {
|
|
return (_c = _dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type.transform)).transform.apply(_c, (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)([_dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type.token)], type.transformArgs));
|
|
}
|
|
return _dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.resolve(type);
|
|
}
|
|
catch (e) {
|
|
var argIndex = index + args.length;
|
|
throw new Error((0,_error_helpers__WEBPACK_IMPORTED_MODULE_3__.formatErrorCtor)(target, argIndex, e));
|
|
}
|
|
})))) || this;
|
|
}
|
|
return class_1;
|
|
}(target));
|
|
};
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (autoInjectable);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/index.js":
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/index.js ***!
|
|
\*************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "autoInjectable": () => (/* reexport safe */ _auto_injectable__WEBPACK_IMPORTED_MODULE_0__["default"]),
|
|
/* harmony export */ "inject": () => (/* reexport safe */ _inject__WEBPACK_IMPORTED_MODULE_1__["default"]),
|
|
/* harmony export */ "injectAll": () => (/* reexport safe */ _inject_all__WEBPACK_IMPORTED_MODULE_5__["default"]),
|
|
/* harmony export */ "injectAllWithTransform": () => (/* reexport safe */ _inject_all_with_transform__WEBPACK_IMPORTED_MODULE_6__["default"]),
|
|
/* harmony export */ "injectWithTransform": () => (/* reexport safe */ _inject_with_transform__WEBPACK_IMPORTED_MODULE_7__["default"]),
|
|
/* harmony export */ "injectable": () => (/* reexport safe */ _injectable__WEBPACK_IMPORTED_MODULE_2__["default"]),
|
|
/* harmony export */ "registry": () => (/* reexport safe */ _registry__WEBPACK_IMPORTED_MODULE_3__["default"]),
|
|
/* harmony export */ "scoped": () => (/* reexport safe */ _scoped__WEBPACK_IMPORTED_MODULE_8__["default"]),
|
|
/* harmony export */ "singleton": () => (/* reexport safe */ _singleton__WEBPACK_IMPORTED_MODULE_4__["default"])
|
|
/* harmony export */ });
|
|
/* harmony import */ var _auto_injectable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./auto-injectable */ "./node_modules/tsyringe/dist/esm5/decorators/auto-injectable.js");
|
|
/* harmony import */ var _inject__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./inject */ "./node_modules/tsyringe/dist/esm5/decorators/inject.js");
|
|
/* harmony import */ var _injectable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./injectable */ "./node_modules/tsyringe/dist/esm5/decorators/injectable.js");
|
|
/* harmony import */ var _registry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./registry */ "./node_modules/tsyringe/dist/esm5/decorators/registry.js");
|
|
/* harmony import */ var _singleton__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./singleton */ "./node_modules/tsyringe/dist/esm5/decorators/singleton.js");
|
|
/* harmony import */ var _inject_all__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./inject-all */ "./node_modules/tsyringe/dist/esm5/decorators/inject-all.js");
|
|
/* harmony import */ var _inject_all_with_transform__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./inject-all-with-transform */ "./node_modules/tsyringe/dist/esm5/decorators/inject-all-with-transform.js");
|
|
/* harmony import */ var _inject_with_transform__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./inject-with-transform */ "./node_modules/tsyringe/dist/esm5/decorators/inject-with-transform.js");
|
|
/* harmony import */ var _scoped__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./scoped */ "./node_modules/tsyringe/dist/esm5/decorators/scoped.js");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/inject-all-with-transform.js":
|
|
/*!*********************************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/inject-all-with-transform.js ***!
|
|
\*********************************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _reflection_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../reflection-helpers */ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js");
|
|
|
|
function injectAllWithTransform(token, transformer) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
var data = {
|
|
token: token,
|
|
multiple: true,
|
|
transform: transformer,
|
|
transformArgs: args
|
|
};
|
|
return (0,_reflection_helpers__WEBPACK_IMPORTED_MODULE_0__.defineInjectionTokenMetadata)(data);
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (injectAllWithTransform);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/inject-all.js":
|
|
/*!******************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/inject-all.js ***!
|
|
\******************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _reflection_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../reflection-helpers */ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js");
|
|
|
|
function injectAll(token) {
|
|
var data = { token: token, multiple: true };
|
|
return (0,_reflection_helpers__WEBPACK_IMPORTED_MODULE_0__.defineInjectionTokenMetadata)(data);
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (injectAll);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/inject-with-transform.js":
|
|
/*!*****************************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/inject-with-transform.js ***!
|
|
\*****************************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _reflection_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../reflection-helpers */ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js");
|
|
|
|
function injectWithTransform(token, transformer) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
return (0,_reflection_helpers__WEBPACK_IMPORTED_MODULE_0__.defineInjectionTokenMetadata)(token, {
|
|
transformToken: transformer,
|
|
args: args
|
|
});
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (injectWithTransform);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/inject.js":
|
|
/*!**************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/inject.js ***!
|
|
\**************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _reflection_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../reflection-helpers */ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js");
|
|
|
|
function inject(token) {
|
|
return (0,_reflection_helpers__WEBPACK_IMPORTED_MODULE_0__.defineInjectionTokenMetadata)(token);
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (inject);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/injectable.js":
|
|
/*!******************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/injectable.js ***!
|
|
\******************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _reflection_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../reflection-helpers */ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js");
|
|
/* harmony import */ var _dependency_container__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../dependency-container */ "./node_modules/tsyringe/dist/esm5/dependency-container.js");
|
|
|
|
|
|
function injectable() {
|
|
return function (target) {
|
|
_dependency_container__WEBPACK_IMPORTED_MODULE_1__.typeInfo.set(target, (0,_reflection_helpers__WEBPACK_IMPORTED_MODULE_0__.getParamInfo)(target));
|
|
};
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (injectable);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/registry.js":
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/registry.js ***!
|
|
\****************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
/* harmony import */ var _dependency_container__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../dependency-container */ "./node_modules/tsyringe/dist/esm5/dependency-container.js");
|
|
|
|
|
|
function registry(registrations) {
|
|
if (registrations === void 0) { registrations = []; }
|
|
return function (target) {
|
|
registrations.forEach(function (_a) {
|
|
var token = _a.token, options = _a.options, provider = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__rest)(_a, ["token", "options"]);
|
|
return _dependency_container__WEBPACK_IMPORTED_MODULE_0__.instance.register(token, provider, options);
|
|
});
|
|
return target;
|
|
};
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (registry);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/scoped.js":
|
|
/*!**************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/scoped.js ***!
|
|
\**************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (/* binding */ scoped)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _injectable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./injectable */ "./node_modules/tsyringe/dist/esm5/decorators/injectable.js");
|
|
/* harmony import */ var _dependency_container__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../dependency-container */ "./node_modules/tsyringe/dist/esm5/dependency-container.js");
|
|
|
|
|
|
function scoped(lifecycle, token) {
|
|
return function (target) {
|
|
(0,_injectable__WEBPACK_IMPORTED_MODULE_0__["default"])()(target);
|
|
_dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.register(token || target, target, {
|
|
lifecycle: lifecycle
|
|
});
|
|
};
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/decorators/singleton.js":
|
|
/*!*****************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/decorators/singleton.js ***!
|
|
\*****************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _injectable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./injectable */ "./node_modules/tsyringe/dist/esm5/decorators/injectable.js");
|
|
/* harmony import */ var _dependency_container__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../dependency-container */ "./node_modules/tsyringe/dist/esm5/dependency-container.js");
|
|
|
|
|
|
function singleton() {
|
|
return function (target) {
|
|
(0,_injectable__WEBPACK_IMPORTED_MODULE_0__["default"])()(target);
|
|
_dependency_container__WEBPACK_IMPORTED_MODULE_1__.instance.registerSingleton(target);
|
|
};
|
|
}
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (singleton);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/dependency-container.js":
|
|
/*!*****************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/dependency-container.js ***!
|
|
\*****************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__),
|
|
/* harmony export */ "instance": () => (/* binding */ instance),
|
|
/* harmony export */ "typeInfo": () => (/* binding */ typeInfo)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
/* harmony import */ var _providers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./providers */ "./node_modules/tsyringe/dist/esm5/providers/index.js");
|
|
/* harmony import */ var _providers_provider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./providers/provider */ "./node_modules/tsyringe/dist/esm5/providers/provider.js");
|
|
/* harmony import */ var _providers_injection_token__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./providers/injection-token */ "./node_modules/tsyringe/dist/esm5/providers/injection-token.js");
|
|
/* harmony import */ var _registry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./registry */ "./node_modules/tsyringe/dist/esm5/registry.js");
|
|
/* harmony import */ var _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./types/lifecycle */ "./node_modules/tsyringe/dist/esm5/types/lifecycle.js");
|
|
/* harmony import */ var _resolution_context__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./resolution-context */ "./node_modules/tsyringe/dist/esm5/resolution-context.js");
|
|
/* harmony import */ var _error_helpers__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./error-helpers */ "./node_modules/tsyringe/dist/esm5/error-helpers.js");
|
|
/* harmony import */ var _lazy_helpers__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./lazy-helpers */ "./node_modules/tsyringe/dist/esm5/lazy-helpers.js");
|
|
/* harmony import */ var _types_disposable__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./types/disposable */ "./node_modules/tsyringe/dist/esm5/types/disposable.js");
|
|
/* harmony import */ var _interceptors__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./interceptors */ "./node_modules/tsyringe/dist/esm5/interceptors.js");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var typeInfo = new Map();
|
|
var InternalDependencyContainer = (function () {
|
|
function InternalDependencyContainer(parent) {
|
|
this.parent = parent;
|
|
this._registry = new _registry__WEBPACK_IMPORTED_MODULE_3__["default"]();
|
|
this.interceptors = new _interceptors__WEBPACK_IMPORTED_MODULE_9__["default"]();
|
|
this.disposed = false;
|
|
this.disposables = new Set();
|
|
}
|
|
InternalDependencyContainer.prototype.register = function (token, providerOrConstructor, options) {
|
|
if (options === void 0) { options = { lifecycle: _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].Transient }; }
|
|
this.ensureNotDisposed();
|
|
var provider;
|
|
if (!(0,_providers_provider__WEBPACK_IMPORTED_MODULE_1__.isProvider)(providerOrConstructor)) {
|
|
provider = { useClass: providerOrConstructor };
|
|
}
|
|
else {
|
|
provider = providerOrConstructor;
|
|
}
|
|
if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isTokenProvider)(provider)) {
|
|
var path = [token];
|
|
var tokenProvider = provider;
|
|
while (tokenProvider != null) {
|
|
var currentToken = tokenProvider.useToken;
|
|
if (path.includes(currentToken)) {
|
|
throw new Error("Token registration cycle detected! " + (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__spread)(path, [currentToken]).join(" -> "));
|
|
}
|
|
path.push(currentToken);
|
|
var registration = this._registry.get(currentToken);
|
|
if (registration && (0,_providers__WEBPACK_IMPORTED_MODULE_0__.isTokenProvider)(registration.provider)) {
|
|
tokenProvider = registration.provider;
|
|
}
|
|
else {
|
|
tokenProvider = null;
|
|
}
|
|
}
|
|
}
|
|
if (options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].Singleton ||
|
|
options.lifecycle == _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ContainerScoped ||
|
|
options.lifecycle == _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ResolutionScoped) {
|
|
if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isValueProvider)(provider) || (0,_providers__WEBPACK_IMPORTED_MODULE_0__.isFactoryProvider)(provider)) {
|
|
throw new Error("Cannot use lifecycle \"" + _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"][options.lifecycle] + "\" with ValueProviders or FactoryProviders");
|
|
}
|
|
}
|
|
this._registry.set(token, { provider: provider, options: options });
|
|
return this;
|
|
};
|
|
InternalDependencyContainer.prototype.registerType = function (from, to) {
|
|
this.ensureNotDisposed();
|
|
if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isNormalToken)(to)) {
|
|
return this.register(from, {
|
|
useToken: to
|
|
});
|
|
}
|
|
return this.register(from, {
|
|
useClass: to
|
|
});
|
|
};
|
|
InternalDependencyContainer.prototype.registerInstance = function (token, instance) {
|
|
this.ensureNotDisposed();
|
|
return this.register(token, {
|
|
useValue: instance
|
|
});
|
|
};
|
|
InternalDependencyContainer.prototype.registerSingleton = function (from, to) {
|
|
this.ensureNotDisposed();
|
|
if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isNormalToken)(from)) {
|
|
if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isNormalToken)(to)) {
|
|
return this.register(from, {
|
|
useToken: to
|
|
}, { lifecycle: _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].Singleton });
|
|
}
|
|
else if (to) {
|
|
return this.register(from, {
|
|
useClass: to
|
|
}, { lifecycle: _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].Singleton });
|
|
}
|
|
throw new Error('Cannot register a type name as a singleton without a "to" token');
|
|
}
|
|
var useClass = from;
|
|
if (to && !(0,_providers__WEBPACK_IMPORTED_MODULE_0__.isNormalToken)(to)) {
|
|
useClass = to;
|
|
}
|
|
return this.register(from, {
|
|
useClass: useClass
|
|
}, { lifecycle: _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].Singleton });
|
|
};
|
|
InternalDependencyContainer.prototype.resolve = function (token, context) {
|
|
if (context === void 0) { context = new _resolution_context__WEBPACK_IMPORTED_MODULE_5__["default"](); }
|
|
this.ensureNotDisposed();
|
|
var registration = this.getRegistration(token);
|
|
if (!registration && (0,_providers__WEBPACK_IMPORTED_MODULE_0__.isNormalToken)(token)) {
|
|
throw new Error("Attempted to resolve unregistered dependency token: \"" + token.toString() + "\"");
|
|
}
|
|
this.executePreResolutionInterceptor(token, "Single");
|
|
if (registration) {
|
|
var result = this.resolveRegistration(registration, context);
|
|
this.executePostResolutionInterceptor(token, result, "Single");
|
|
return result;
|
|
}
|
|
if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isConstructorToken)(token)) {
|
|
var result = this.construct(token, context);
|
|
this.executePostResolutionInterceptor(token, result, "Single");
|
|
return result;
|
|
}
|
|
throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
|
|
};
|
|
InternalDependencyContainer.prototype.executePreResolutionInterceptor = function (token, resolutionType) {
|
|
var e_1, _a;
|
|
if (this.interceptors.preResolution.has(token)) {
|
|
var remainingInterceptors = [];
|
|
try {
|
|
for (var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__values)(this.interceptors.preResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var interceptor = _c.value;
|
|
if (interceptor.options.frequency != "Once") {
|
|
remainingInterceptors.push(interceptor);
|
|
}
|
|
interceptor.callback(token, resolutionType);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
this.interceptors.preResolution.setAll(token, remainingInterceptors);
|
|
}
|
|
};
|
|
InternalDependencyContainer.prototype.executePostResolutionInterceptor = function (token, result, resolutionType) {
|
|
var e_2, _a;
|
|
if (this.interceptors.postResolution.has(token)) {
|
|
var remainingInterceptors = [];
|
|
try {
|
|
for (var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__values)(this.interceptors.postResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var interceptor = _c.value;
|
|
if (interceptor.options.frequency != "Once") {
|
|
remainingInterceptors.push(interceptor);
|
|
}
|
|
interceptor.callback(token, result, resolutionType);
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
this.interceptors.postResolution.setAll(token, remainingInterceptors);
|
|
}
|
|
};
|
|
InternalDependencyContainer.prototype.resolveRegistration = function (registration, context) {
|
|
this.ensureNotDisposed();
|
|
if (registration.options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ResolutionScoped &&
|
|
context.scopedResolutions.has(registration)) {
|
|
return context.scopedResolutions.get(registration);
|
|
}
|
|
var isSingleton = registration.options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].Singleton;
|
|
var isContainerScoped = registration.options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ContainerScoped;
|
|
var returnInstance = isSingleton || isContainerScoped;
|
|
var resolved;
|
|
if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isValueProvider)(registration.provider)) {
|
|
resolved = registration.provider.useValue;
|
|
}
|
|
else if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isTokenProvider)(registration.provider)) {
|
|
resolved = returnInstance
|
|
? registration.instance ||
|
|
(registration.instance = this.resolve(registration.provider.useToken, context))
|
|
: this.resolve(registration.provider.useToken, context);
|
|
}
|
|
else if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isClassProvider)(registration.provider)) {
|
|
resolved = returnInstance
|
|
? registration.instance ||
|
|
(registration.instance = this.construct(registration.provider.useClass, context))
|
|
: this.construct(registration.provider.useClass, context);
|
|
}
|
|
else if ((0,_providers__WEBPACK_IMPORTED_MODULE_0__.isFactoryProvider)(registration.provider)) {
|
|
resolved = registration.provider.useFactory(this);
|
|
}
|
|
else {
|
|
resolved = this.construct(registration.provider, context);
|
|
}
|
|
if (registration.options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ResolutionScoped) {
|
|
context.scopedResolutions.set(registration, resolved);
|
|
}
|
|
return resolved;
|
|
};
|
|
InternalDependencyContainer.prototype.resolveAll = function (token, context) {
|
|
var _this = this;
|
|
if (context === void 0) { context = new _resolution_context__WEBPACK_IMPORTED_MODULE_5__["default"](); }
|
|
this.ensureNotDisposed();
|
|
var registrations = this.getAllRegistrations(token);
|
|
if (!registrations && (0,_providers__WEBPACK_IMPORTED_MODULE_0__.isNormalToken)(token)) {
|
|
throw new Error("Attempted to resolve unregistered dependency token: \"" + token.toString() + "\"");
|
|
}
|
|
this.executePreResolutionInterceptor(token, "All");
|
|
if (registrations) {
|
|
var result_1 = registrations.map(function (item) {
|
|
return _this.resolveRegistration(item, context);
|
|
});
|
|
this.executePostResolutionInterceptor(token, result_1, "All");
|
|
return result_1;
|
|
}
|
|
var result = [this.construct(token, context)];
|
|
this.executePostResolutionInterceptor(token, result, "All");
|
|
return result;
|
|
};
|
|
InternalDependencyContainer.prototype.isRegistered = function (token, recursive) {
|
|
if (recursive === void 0) { recursive = false; }
|
|
this.ensureNotDisposed();
|
|
return (this._registry.has(token) ||
|
|
(recursive &&
|
|
(this.parent || false) &&
|
|
this.parent.isRegistered(token, true)));
|
|
};
|
|
InternalDependencyContainer.prototype.reset = function () {
|
|
this.ensureNotDisposed();
|
|
this._registry.clear();
|
|
this.interceptors.preResolution.clear();
|
|
this.interceptors.postResolution.clear();
|
|
};
|
|
InternalDependencyContainer.prototype.clearInstances = function () {
|
|
var e_3, _a;
|
|
this.ensureNotDisposed();
|
|
try {
|
|
for (var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__values)(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var _d = (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__read)(_c.value, 2), token = _d[0], registrations = _d[1];
|
|
this._registry.setAll(token, registrations
|
|
.filter(function (registration) { return !(0,_providers__WEBPACK_IMPORTED_MODULE_0__.isValueProvider)(registration.provider); })
|
|
.map(function (registration) {
|
|
registration.instance = undefined;
|
|
return registration;
|
|
}));
|
|
}
|
|
}
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_3) throw e_3.error; }
|
|
}
|
|
};
|
|
InternalDependencyContainer.prototype.createChildContainer = function () {
|
|
var e_4, _a;
|
|
this.ensureNotDisposed();
|
|
var childContainer = new InternalDependencyContainer(this);
|
|
try {
|
|
for (var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__values)(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var _d = (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__read)(_c.value, 2), token = _d[0], registrations = _d[1];
|
|
if (registrations.some(function (_a) {
|
|
var options = _a.options;
|
|
return options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ContainerScoped;
|
|
})) {
|
|
childContainer._registry.setAll(token, registrations.map(function (registration) {
|
|
if (registration.options.lifecycle === _types_lifecycle__WEBPACK_IMPORTED_MODULE_4__["default"].ContainerScoped) {
|
|
return {
|
|
provider: registration.provider,
|
|
options: registration.options
|
|
};
|
|
}
|
|
return registration;
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_4) throw e_4.error; }
|
|
}
|
|
return childContainer;
|
|
};
|
|
InternalDependencyContainer.prototype.beforeResolution = function (token, callback, options) {
|
|
if (options === void 0) { options = { frequency: "Always" }; }
|
|
this.interceptors.preResolution.set(token, {
|
|
callback: callback,
|
|
options: options
|
|
});
|
|
};
|
|
InternalDependencyContainer.prototype.afterResolution = function (token, callback, options) {
|
|
if (options === void 0) { options = { frequency: "Always" }; }
|
|
this.interceptors.postResolution.set(token, {
|
|
callback: callback,
|
|
options: options
|
|
});
|
|
};
|
|
InternalDependencyContainer.prototype.dispose = function () {
|
|
return (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__awaiter)(this, void 0, void 0, function () {
|
|
var promises;
|
|
return (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__generator)(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
this.disposed = true;
|
|
promises = [];
|
|
this.disposables.forEach(function (disposable) {
|
|
var maybePromise = disposable.dispose();
|
|
if (maybePromise) {
|
|
promises.push(maybePromise);
|
|
}
|
|
});
|
|
return [4, Promise.all(promises)];
|
|
case 1:
|
|
_a.sent();
|
|
return [2];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
InternalDependencyContainer.prototype.getRegistration = function (token) {
|
|
if (this.isRegistered(token)) {
|
|
return this._registry.get(token);
|
|
}
|
|
if (this.parent) {
|
|
return this.parent.getRegistration(token);
|
|
}
|
|
return null;
|
|
};
|
|
InternalDependencyContainer.prototype.getAllRegistrations = function (token) {
|
|
if (this.isRegistered(token)) {
|
|
return this._registry.getAll(token);
|
|
}
|
|
if (this.parent) {
|
|
return this.parent.getAllRegistrations(token);
|
|
}
|
|
return null;
|
|
};
|
|
InternalDependencyContainer.prototype.construct = function (ctor, context) {
|
|
var _this = this;
|
|
if (ctor instanceof _lazy_helpers__WEBPACK_IMPORTED_MODULE_7__.DelayedConstructor) {
|
|
return ctor.createProxy(function (target) {
|
|
return _this.resolve(target, context);
|
|
});
|
|
}
|
|
var instance = (function () {
|
|
var paramInfo = typeInfo.get(ctor);
|
|
if (!paramInfo || paramInfo.length === 0) {
|
|
if (ctor.length === 0) {
|
|
return new ctor();
|
|
}
|
|
else {
|
|
throw new Error("TypeInfo not known for \"" + ctor.name + "\"");
|
|
}
|
|
}
|
|
var params = paramInfo.map(_this.resolveParams(context, ctor));
|
|
return new (ctor.bind.apply(ctor, (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__spread)([void 0], params)))();
|
|
})();
|
|
if ((0,_types_disposable__WEBPACK_IMPORTED_MODULE_8__.isDisposable)(instance)) {
|
|
this.disposables.add(instance);
|
|
}
|
|
return instance;
|
|
};
|
|
InternalDependencyContainer.prototype.resolveParams = function (context, ctor) {
|
|
var _this = this;
|
|
return function (param, idx) {
|
|
var _a, _b, _c;
|
|
try {
|
|
if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isTokenDescriptor)(param)) {
|
|
if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isTransformDescriptor)(param)) {
|
|
return param.multiple
|
|
? (_a = _this.resolve(param.transform)).transform.apply(_a, (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__spread)([_this.resolveAll(param.token)], param.transformArgs)) : (_b = _this.resolve(param.transform)).transform.apply(_b, (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__spread)([_this.resolve(param.token, context)], param.transformArgs));
|
|
}
|
|
else {
|
|
return param.multiple
|
|
? _this.resolveAll(param.token)
|
|
: _this.resolve(param.token, context);
|
|
}
|
|
}
|
|
else if ((0,_providers_injection_token__WEBPACK_IMPORTED_MODULE_2__.isTransformDescriptor)(param)) {
|
|
return (_c = _this.resolve(param.transform, context)).transform.apply(_c, (0,tslib__WEBPACK_IMPORTED_MODULE_10__.__spread)([_this.resolve(param.token, context)], param.transformArgs));
|
|
}
|
|
return _this.resolve(param, context);
|
|
}
|
|
catch (e) {
|
|
throw new Error((0,_error_helpers__WEBPACK_IMPORTED_MODULE_6__.formatErrorCtor)(ctor, idx, e));
|
|
}
|
|
};
|
|
};
|
|
InternalDependencyContainer.prototype.ensureNotDisposed = function () {
|
|
if (this.disposed) {
|
|
throw new Error("This container has been disposed, you cannot interact with a disposed container");
|
|
}
|
|
};
|
|
return InternalDependencyContainer;
|
|
}());
|
|
var instance = new InternalDependencyContainer();
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (instance);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/error-helpers.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/error-helpers.js ***!
|
|
\**********************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "formatErrorCtor": () => (/* binding */ formatErrorCtor)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
|
|
function formatDependency(params, idx) {
|
|
if (params === null) {
|
|
return "at position #" + idx;
|
|
}
|
|
var argName = params.split(",")[idx].trim();
|
|
return "\"" + argName + "\" at position #" + idx;
|
|
}
|
|
function composeErrorMessage(msg, e, indent) {
|
|
if (indent === void 0) { indent = " "; }
|
|
return (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spread)([msg], e.message.split("\n").map(function (l) { return indent + l; })).join("\n");
|
|
}
|
|
function formatErrorCtor(ctor, paramIdx, error) {
|
|
var _a = (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__read)(ctor.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), _b = _a[1], params = _b === void 0 ? null : _b;
|
|
var dep = formatDependency(params, paramIdx);
|
|
return composeErrorMessage("Cannot inject the dependency " + dep + " of \"" + ctor.name + "\" constructor. Reason:", error);
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/factories/index.js":
|
|
/*!************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/factories/index.js ***!
|
|
\************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "instanceCachingFactory": () => (/* reexport safe */ _instance_caching_factory__WEBPACK_IMPORTED_MODULE_0__["default"]),
|
|
/* harmony export */ "instancePerContainerCachingFactory": () => (/* reexport safe */ _instance_per_container_caching_factory__WEBPACK_IMPORTED_MODULE_1__["default"]),
|
|
/* harmony export */ "predicateAwareClassFactory": () => (/* reexport safe */ _predicate_aware_class_factory__WEBPACK_IMPORTED_MODULE_2__["default"])
|
|
/* harmony export */ });
|
|
/* harmony import */ var _instance_caching_factory__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./instance-caching-factory */ "./node_modules/tsyringe/dist/esm5/factories/instance-caching-factory.js");
|
|
/* harmony import */ var _instance_per_container_caching_factory__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./instance-per-container-caching-factory */ "./node_modules/tsyringe/dist/esm5/factories/instance-per-container-caching-factory.js");
|
|
/* harmony import */ var _predicate_aware_class_factory__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./predicate-aware-class-factory */ "./node_modules/tsyringe/dist/esm5/factories/predicate-aware-class-factory.js");
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/factories/instance-caching-factory.js":
|
|
/*!*******************************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/factories/instance-caching-factory.js ***!
|
|
\*******************************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (/* binding */ instanceCachingFactory)
|
|
/* harmony export */ });
|
|
function instanceCachingFactory(factoryFunc) {
|
|
var instance;
|
|
return function (dependencyContainer) {
|
|
if (instance == undefined) {
|
|
instance = factoryFunc(dependencyContainer);
|
|
}
|
|
return instance;
|
|
};
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/factories/instance-per-container-caching-factory.js":
|
|
/*!*********************************************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/factories/instance-per-container-caching-factory.js ***!
|
|
\*********************************************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (/* binding */ instancePerContainerCachingFactory)
|
|
/* harmony export */ });
|
|
function instancePerContainerCachingFactory(factoryFunc) {
|
|
var cache = new WeakMap();
|
|
return function (dependencyContainer) {
|
|
var instance = cache.get(dependencyContainer);
|
|
if (instance == undefined) {
|
|
instance = factoryFunc(dependencyContainer);
|
|
cache.set(dependencyContainer, instance);
|
|
}
|
|
return instance;
|
|
};
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/factories/predicate-aware-class-factory.js":
|
|
/*!************************************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/factories/predicate-aware-class-factory.js ***!
|
|
\************************************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (/* binding */ predicateAwareClassFactory)
|
|
/* harmony export */ });
|
|
function predicateAwareClassFactory(predicate, trueConstructor, falseConstructor, useCaching) {
|
|
if (useCaching === void 0) { useCaching = true; }
|
|
var instance;
|
|
var previousPredicate;
|
|
return function (dependencyContainer) {
|
|
var currentPredicate = predicate(dependencyContainer);
|
|
if (!useCaching || previousPredicate !== currentPredicate) {
|
|
if ((previousPredicate = currentPredicate)) {
|
|
instance = dependencyContainer.resolve(trueConstructor);
|
|
}
|
|
else {
|
|
instance = dependencyContainer.resolve(falseConstructor);
|
|
}
|
|
}
|
|
return instance;
|
|
};
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/index.js":
|
|
/*!**************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/index.js ***!
|
|
\**************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "Lifecycle": () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_0__.Lifecycle),
|
|
/* harmony export */ "autoInjectable": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.autoInjectable),
|
|
/* harmony export */ "container": () => (/* reexport safe */ _dependency_container__WEBPACK_IMPORTED_MODULE_5__.instance),
|
|
/* harmony export */ "delay": () => (/* reexport safe */ _lazy_helpers__WEBPACK_IMPORTED_MODULE_4__.delay),
|
|
/* harmony export */ "inject": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.inject),
|
|
/* harmony export */ "injectAll": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.injectAll),
|
|
/* harmony export */ "injectAllWithTransform": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.injectAllWithTransform),
|
|
/* harmony export */ "injectWithTransform": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.injectWithTransform),
|
|
/* harmony export */ "injectable": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.injectable),
|
|
/* harmony export */ "instanceCachingFactory": () => (/* reexport safe */ _factories__WEBPACK_IMPORTED_MODULE_2__.instanceCachingFactory),
|
|
/* harmony export */ "instancePerContainerCachingFactory": () => (/* reexport safe */ _factories__WEBPACK_IMPORTED_MODULE_2__.instancePerContainerCachingFactory),
|
|
/* harmony export */ "isClassProvider": () => (/* reexport safe */ _providers__WEBPACK_IMPORTED_MODULE_3__.isClassProvider),
|
|
/* harmony export */ "isFactoryProvider": () => (/* reexport safe */ _providers__WEBPACK_IMPORTED_MODULE_3__.isFactoryProvider),
|
|
/* harmony export */ "isNormalToken": () => (/* reexport safe */ _providers__WEBPACK_IMPORTED_MODULE_3__.isNormalToken),
|
|
/* harmony export */ "isTokenProvider": () => (/* reexport safe */ _providers__WEBPACK_IMPORTED_MODULE_3__.isTokenProvider),
|
|
/* harmony export */ "isValueProvider": () => (/* reexport safe */ _providers__WEBPACK_IMPORTED_MODULE_3__.isValueProvider),
|
|
/* harmony export */ "predicateAwareClassFactory": () => (/* reexport safe */ _factories__WEBPACK_IMPORTED_MODULE_2__.predicateAwareClassFactory),
|
|
/* harmony export */ "registry": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.registry),
|
|
/* harmony export */ "scoped": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.scoped),
|
|
/* harmony export */ "singleton": () => (/* reexport safe */ _decorators__WEBPACK_IMPORTED_MODULE_1__.singleton)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types */ "./node_modules/tsyringe/dist/esm5/types/index.js");
|
|
/* harmony import */ var _decorators__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./decorators */ "./node_modules/tsyringe/dist/esm5/decorators/index.js");
|
|
/* harmony import */ var _factories__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./factories */ "./node_modules/tsyringe/dist/esm5/factories/index.js");
|
|
/* harmony import */ var _providers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./providers */ "./node_modules/tsyringe/dist/esm5/providers/index.js");
|
|
/* harmony import */ var _lazy_helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./lazy-helpers */ "./node_modules/tsyringe/dist/esm5/lazy-helpers.js");
|
|
/* harmony import */ var _dependency_container__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./dependency-container */ "./node_modules/tsyringe/dist/esm5/dependency-container.js");
|
|
if (typeof Reflect === "undefined" || !Reflect.getMetadata) {
|
|
throw new Error("tsyringe requires a reflect polyfill. Please add 'import \"reflect-metadata\"' to the top of your entry point.");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/interceptors.js":
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/interceptors.js ***!
|
|
\*********************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "PostResolutionInterceptors": () => (/* binding */ PostResolutionInterceptors),
|
|
/* harmony export */ "PreResolutionInterceptors": () => (/* binding */ PreResolutionInterceptors),
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
/* harmony import */ var _registry_base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./registry-base */ "./node_modules/tsyringe/dist/esm5/registry-base.js");
|
|
|
|
|
|
var PreResolutionInterceptors = (function (_super) {
|
|
(0,tslib__WEBPACK_IMPORTED_MODULE_1__.__extends)(PreResolutionInterceptors, _super);
|
|
function PreResolutionInterceptors() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
return PreResolutionInterceptors;
|
|
}(_registry_base__WEBPACK_IMPORTED_MODULE_0__["default"]));
|
|
|
|
var PostResolutionInterceptors = (function (_super) {
|
|
(0,tslib__WEBPACK_IMPORTED_MODULE_1__.__extends)(PostResolutionInterceptors, _super);
|
|
function PostResolutionInterceptors() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
return PostResolutionInterceptors;
|
|
}(_registry_base__WEBPACK_IMPORTED_MODULE_0__["default"]));
|
|
|
|
var Interceptors = (function () {
|
|
function Interceptors() {
|
|
this.preResolution = new PreResolutionInterceptors();
|
|
this.postResolution = new PostResolutionInterceptors();
|
|
}
|
|
return Interceptors;
|
|
}());
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Interceptors);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/lazy-helpers.js":
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/lazy-helpers.js ***!
|
|
\*********************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "DelayedConstructor": () => (/* binding */ DelayedConstructor),
|
|
/* harmony export */ "delay": () => (/* binding */ delay)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
|
|
var DelayedConstructor = (function () {
|
|
function DelayedConstructor(wrap) {
|
|
this.wrap = wrap;
|
|
this.reflectMethods = [
|
|
"get",
|
|
"getPrototypeOf",
|
|
"setPrototypeOf",
|
|
"getOwnPropertyDescriptor",
|
|
"defineProperty",
|
|
"has",
|
|
"set",
|
|
"deleteProperty",
|
|
"apply",
|
|
"construct",
|
|
"ownKeys"
|
|
];
|
|
}
|
|
DelayedConstructor.prototype.createProxy = function (createObject) {
|
|
var _this = this;
|
|
var target = {};
|
|
var init = false;
|
|
var value;
|
|
var delayedObject = function () {
|
|
if (!init) {
|
|
value = createObject(_this.wrap());
|
|
init = true;
|
|
}
|
|
return value;
|
|
};
|
|
return new Proxy(target, this.createHandler(delayedObject));
|
|
};
|
|
DelayedConstructor.prototype.createHandler = function (delayedObject) {
|
|
var handler = {};
|
|
var install = function (name) {
|
|
handler[name] = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
args[0] = delayedObject();
|
|
var method = Reflect[name];
|
|
return method.apply(void 0, (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spread)(args));
|
|
};
|
|
};
|
|
this.reflectMethods.forEach(install);
|
|
return handler;
|
|
};
|
|
return DelayedConstructor;
|
|
}());
|
|
|
|
function delay(wrappedConstructor) {
|
|
if (typeof wrappedConstructor === "undefined") {
|
|
throw new Error("Attempt to `delay` undefined. Constructor must be wrapped in a callback");
|
|
}
|
|
return new DelayedConstructor(wrappedConstructor);
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/class-provider.js":
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/class-provider.js ***!
|
|
\*********************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isClassProvider": () => (/* binding */ isClassProvider)
|
|
/* harmony export */ });
|
|
function isClassProvider(provider) {
|
|
return !!provider.useClass;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/factory-provider.js":
|
|
/*!***********************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/factory-provider.js ***!
|
|
\***********************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isFactoryProvider": () => (/* binding */ isFactoryProvider)
|
|
/* harmony export */ });
|
|
function isFactoryProvider(provider) {
|
|
return !!provider.useFactory;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/index.js":
|
|
/*!************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/index.js ***!
|
|
\************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isClassProvider": () => (/* reexport safe */ _class_provider__WEBPACK_IMPORTED_MODULE_0__.isClassProvider),
|
|
/* harmony export */ "isFactoryProvider": () => (/* reexport safe */ _factory_provider__WEBPACK_IMPORTED_MODULE_1__.isFactoryProvider),
|
|
/* harmony export */ "isNormalToken": () => (/* reexport safe */ _injection_token__WEBPACK_IMPORTED_MODULE_2__.isNormalToken),
|
|
/* harmony export */ "isTokenProvider": () => (/* reexport safe */ _token_provider__WEBPACK_IMPORTED_MODULE_3__.isTokenProvider),
|
|
/* harmony export */ "isValueProvider": () => (/* reexport safe */ _value_provider__WEBPACK_IMPORTED_MODULE_4__.isValueProvider)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _class_provider__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./class-provider */ "./node_modules/tsyringe/dist/esm5/providers/class-provider.js");
|
|
/* harmony import */ var _factory_provider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./factory-provider */ "./node_modules/tsyringe/dist/esm5/providers/factory-provider.js");
|
|
/* harmony import */ var _injection_token__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./injection-token */ "./node_modules/tsyringe/dist/esm5/providers/injection-token.js");
|
|
/* harmony import */ var _token_provider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./token-provider */ "./node_modules/tsyringe/dist/esm5/providers/token-provider.js");
|
|
/* harmony import */ var _value_provider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./value-provider */ "./node_modules/tsyringe/dist/esm5/providers/value-provider.js");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/injection-token.js":
|
|
/*!**********************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/injection-token.js ***!
|
|
\**********************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isConstructorToken": () => (/* binding */ isConstructorToken),
|
|
/* harmony export */ "isNormalToken": () => (/* binding */ isNormalToken),
|
|
/* harmony export */ "isTokenDescriptor": () => (/* binding */ isTokenDescriptor),
|
|
/* harmony export */ "isTransformDescriptor": () => (/* binding */ isTransformDescriptor)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _lazy_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../lazy-helpers */ "./node_modules/tsyringe/dist/esm5/lazy-helpers.js");
|
|
|
|
function isNormalToken(token) {
|
|
return typeof token === "string" || typeof token === "symbol";
|
|
}
|
|
function isTokenDescriptor(descriptor) {
|
|
return (typeof descriptor === "object" &&
|
|
"token" in descriptor &&
|
|
"multiple" in descriptor);
|
|
}
|
|
function isTransformDescriptor(descriptor) {
|
|
return (typeof descriptor === "object" &&
|
|
"token" in descriptor &&
|
|
"transform" in descriptor);
|
|
}
|
|
function isConstructorToken(token) {
|
|
return typeof token === "function" || token instanceof _lazy_helpers__WEBPACK_IMPORTED_MODULE_0__.DelayedConstructor;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/provider.js":
|
|
/*!***************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/provider.js ***!
|
|
\***************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isProvider": () => (/* binding */ isProvider)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _class_provider__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./class-provider */ "./node_modules/tsyringe/dist/esm5/providers/class-provider.js");
|
|
/* harmony import */ var _value_provider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./value-provider */ "./node_modules/tsyringe/dist/esm5/providers/value-provider.js");
|
|
/* harmony import */ var _token_provider__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./token-provider */ "./node_modules/tsyringe/dist/esm5/providers/token-provider.js");
|
|
/* harmony import */ var _factory_provider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./factory-provider */ "./node_modules/tsyringe/dist/esm5/providers/factory-provider.js");
|
|
|
|
|
|
|
|
|
|
function isProvider(provider) {
|
|
return ((0,_class_provider__WEBPACK_IMPORTED_MODULE_0__.isClassProvider)(provider) ||
|
|
(0,_value_provider__WEBPACK_IMPORTED_MODULE_1__.isValueProvider)(provider) ||
|
|
(0,_token_provider__WEBPACK_IMPORTED_MODULE_2__.isTokenProvider)(provider) ||
|
|
(0,_factory_provider__WEBPACK_IMPORTED_MODULE_3__.isFactoryProvider)(provider));
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/token-provider.js":
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/token-provider.js ***!
|
|
\*********************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isTokenProvider": () => (/* binding */ isTokenProvider)
|
|
/* harmony export */ });
|
|
function isTokenProvider(provider) {
|
|
return !!provider.useToken;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/providers/value-provider.js":
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/providers/value-provider.js ***!
|
|
\*********************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isValueProvider": () => (/* binding */ isValueProvider)
|
|
/* harmony export */ });
|
|
function isValueProvider(provider) {
|
|
return provider.useValue != undefined;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/reflection-helpers.js":
|
|
/*!***************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/reflection-helpers.js ***!
|
|
\***************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "INJECTION_TOKEN_METADATA_KEY": () => (/* binding */ INJECTION_TOKEN_METADATA_KEY),
|
|
/* harmony export */ "defineInjectionTokenMetadata": () => (/* binding */ defineInjectionTokenMetadata),
|
|
/* harmony export */ "getParamInfo": () => (/* binding */ getParamInfo)
|
|
/* harmony export */ });
|
|
var INJECTION_TOKEN_METADATA_KEY = "injectionTokens";
|
|
function getParamInfo(target) {
|
|
var params = Reflect.getMetadata("design:paramtypes", target) || [];
|
|
var injectionTokens = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
|
|
Object.keys(injectionTokens).forEach(function (key) {
|
|
params[+key] = injectionTokens[key];
|
|
});
|
|
return params;
|
|
}
|
|
function defineInjectionTokenMetadata(data, transform) {
|
|
return function (target, _propertyKey, parameterIndex) {
|
|
var descriptors = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
|
|
descriptors[parameterIndex] = transform
|
|
? {
|
|
token: data,
|
|
transform: transform.transformToken,
|
|
transformArgs: transform.args || []
|
|
}
|
|
: data;
|
|
Reflect.defineMetadata(INJECTION_TOKEN_METADATA_KEY, descriptors, target);
|
|
};
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/registry-base.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/registry-base.js ***!
|
|
\**********************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
var RegistryBase = (function () {
|
|
function RegistryBase() {
|
|
this._registryMap = new Map();
|
|
}
|
|
RegistryBase.prototype.entries = function () {
|
|
return this._registryMap.entries();
|
|
};
|
|
RegistryBase.prototype.getAll = function (key) {
|
|
this.ensure(key);
|
|
return this._registryMap.get(key);
|
|
};
|
|
RegistryBase.prototype.get = function (key) {
|
|
this.ensure(key);
|
|
var value = this._registryMap.get(key);
|
|
return value[value.length - 1] || null;
|
|
};
|
|
RegistryBase.prototype.set = function (key, value) {
|
|
this.ensure(key);
|
|
this._registryMap.get(key).push(value);
|
|
};
|
|
RegistryBase.prototype.setAll = function (key, value) {
|
|
this._registryMap.set(key, value);
|
|
};
|
|
RegistryBase.prototype.has = function (key) {
|
|
this.ensure(key);
|
|
return this._registryMap.get(key).length > 0;
|
|
};
|
|
RegistryBase.prototype.clear = function () {
|
|
this._registryMap.clear();
|
|
};
|
|
RegistryBase.prototype.ensure = function (key) {
|
|
if (!this._registryMap.has(key)) {
|
|
this._registryMap.set(key, []);
|
|
}
|
|
};
|
|
return RegistryBase;
|
|
}());
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (RegistryBase);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/registry.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/registry.js ***!
|
|
\*****************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.js");
|
|
/* harmony import */ var _registry_base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./registry-base */ "./node_modules/tsyringe/dist/esm5/registry-base.js");
|
|
|
|
|
|
var Registry = (function (_super) {
|
|
(0,tslib__WEBPACK_IMPORTED_MODULE_1__.__extends)(Registry, _super);
|
|
function Registry() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
return Registry;
|
|
}(_registry_base__WEBPACK_IMPORTED_MODULE_0__["default"]));
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Registry);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/resolution-context.js":
|
|
/*!***************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/resolution-context.js ***!
|
|
\***************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
var ResolutionContext = (function () {
|
|
function ResolutionContext() {
|
|
this.scopedResolutions = new Map();
|
|
}
|
|
return ResolutionContext;
|
|
}());
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ResolutionContext);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/types/disposable.js":
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/types/disposable.js ***!
|
|
\*************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "isDisposable": () => (/* binding */ isDisposable)
|
|
/* harmony export */ });
|
|
function isDisposable(value) {
|
|
if (typeof value.dispose !== "function")
|
|
return false;
|
|
var disposeFun = value.dispose;
|
|
if (disposeFun.length > 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/types/index.js":
|
|
/*!********************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/types/index.js ***!
|
|
\********************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "Lifecycle": () => (/* reexport safe */ _lifecycle__WEBPACK_IMPORTED_MODULE_0__["default"])
|
|
/* harmony export */ });
|
|
/* harmony import */ var _lifecycle__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./lifecycle */ "./node_modules/tsyringe/dist/esm5/types/lifecycle.js");
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/tsyringe/dist/esm5/types/lifecycle.js":
|
|
/*!************************************************************!*\
|
|
!*** ./node_modules/tsyringe/dist/esm5/types/lifecycle.js ***!
|
|
\************************************************************/
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
/* harmony export */ });
|
|
var Lifecycle;
|
|
(function (Lifecycle) {
|
|
Lifecycle[Lifecycle["Transient"] = 0] = "Transient";
|
|
Lifecycle[Lifecycle["Singleton"] = 1] = "Singleton";
|
|
Lifecycle[Lifecycle["ResolutionScoped"] = 2] = "ResolutionScoped";
|
|
Lifecycle[Lifecycle["ContainerScoped"] = 3] = "ContainerScoped";
|
|
})(Lifecycle || (Lifecycle = {}));
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Lifecycle);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "path":
|
|
/*!***********************!*\
|
|
!*** external "path" ***!
|
|
\***********************/
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
module.exports = require("path");
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
/************************************************************************/
|
|
/******/ // The module cache
|
|
/******/ var __webpack_module_cache__ = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/ // Check if module is in cache
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
/******/ if (cachedModule !== undefined) {
|
|
/******/ if (cachedModule.error !== undefined) throw cachedModule.error;
|
|
/******/ return cachedModule.exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
/******/ // no module.id needed
|
|
/******/ // no module.loaded needed
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ try {
|
|
/******/ var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };
|
|
/******/ __webpack_require__.i.forEach(function(handler) { handler(execOptions); });
|
|
/******/ module = execOptions.module;
|
|
/******/ execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
|
|
/******/ } catch(e) {
|
|
/******/ module.error = e;
|
|
/******/ throw e;
|
|
/******/ }
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = __webpack_modules__;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = __webpack_module_cache__;
|
|
/******/
|
|
/******/ // expose the module execution interceptor
|
|
/******/ __webpack_require__.i = [];
|
|
/******/
|
|
/************************************************************************/
|
|
/******/ /* webpack/runtime/define property getters */
|
|
/******/ (() => {
|
|
/******/ // define getter functions for harmony exports
|
|
/******/ __webpack_require__.d = (exports, definition) => {
|
|
/******/ for(var key in definition) {
|
|
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
|
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
|
/******/ }
|
|
/******/ }
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/get javascript update chunk filename */
|
|
/******/ (() => {
|
|
/******/ // This function allow to reference all chunks
|
|
/******/ __webpack_require__.hu = (chunkId) => {
|
|
/******/ // return url for filenames based on template
|
|
/******/ return "" + chunkId + "." + __webpack_require__.h() + ".hot-update.js";
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/get update manifest filename */
|
|
/******/ (() => {
|
|
/******/ __webpack_require__.hmrF = () => ("server." + __webpack_require__.h() + ".hot-update.json");
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/getFullHash */
|
|
/******/ (() => {
|
|
/******/ __webpack_require__.h = () => ("c7d7db329f832a80ec56")
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
|
/******/ (() => {
|
|
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/make namespace object */
|
|
/******/ (() => {
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = (exports) => {
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
/******/ }
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/hot module replacement */
|
|
/******/ (() => {
|
|
/******/ var currentModuleData = {};
|
|
/******/ var installedModules = __webpack_require__.c;
|
|
/******/
|
|
/******/ // module and require creation
|
|
/******/ var currentChildModule;
|
|
/******/ var currentParents = [];
|
|
/******/
|
|
/******/ // status
|
|
/******/ var registeredStatusHandlers = [];
|
|
/******/ var currentStatus = "idle";
|
|
/******/
|
|
/******/ // while downloading
|
|
/******/ var blockingPromises = 0;
|
|
/******/ var blockingPromisesWaiting = [];
|
|
/******/
|
|
/******/ // The update info
|
|
/******/ var currentUpdateApplyHandlers;
|
|
/******/ var queuedInvalidatedModules;
|
|
/******/
|
|
/******/ // eslint-disable-next-line no-unused-vars
|
|
/******/ __webpack_require__.hmrD = currentModuleData;
|
|
/******/
|
|
/******/ __webpack_require__.i.push(function (options) {
|
|
/******/ var module = options.module;
|
|
/******/ var require = createRequire(options.require, options.id);
|
|
/******/ module.hot = createModuleHotObject(options.id, module);
|
|
/******/ module.parents = currentParents;
|
|
/******/ module.children = [];
|
|
/******/ currentParents = [];
|
|
/******/ options.require = require;
|
|
/******/ });
|
|
/******/
|
|
/******/ __webpack_require__.hmrC = {};
|
|
/******/ __webpack_require__.hmrI = {};
|
|
/******/
|
|
/******/ function createRequire(require, moduleId) {
|
|
/******/ var me = installedModules[moduleId];
|
|
/******/ if (!me) return require;
|
|
/******/ var fn = function (request) {
|
|
/******/ if (me.hot.active) {
|
|
/******/ if (installedModules[request]) {
|
|
/******/ var parents = installedModules[request].parents;
|
|
/******/ if (parents.indexOf(moduleId) === -1) {
|
|
/******/ parents.push(moduleId);
|
|
/******/ }
|
|
/******/ } else {
|
|
/******/ currentParents = [moduleId];
|
|
/******/ currentChildModule = request;
|
|
/******/ }
|
|
/******/ if (me.children.indexOf(request) === -1) {
|
|
/******/ me.children.push(request);
|
|
/******/ }
|
|
/******/ } else {
|
|
/******/ console.warn(
|
|
/******/ "[HMR] unexpected require(" +
|
|
/******/ request +
|
|
/******/ ") from disposed module " +
|
|
/******/ moduleId
|
|
/******/ );
|
|
/******/ currentParents = [];
|
|
/******/ }
|
|
/******/ return require(request);
|
|
/******/ };
|
|
/******/ var createPropertyDescriptor = function (name) {
|
|
/******/ return {
|
|
/******/ configurable: true,
|
|
/******/ enumerable: true,
|
|
/******/ get: function () {
|
|
/******/ return require[name];
|
|
/******/ },
|
|
/******/ set: function (value) {
|
|
/******/ require[name] = value;
|
|
/******/ }
|
|
/******/ };
|
|
/******/ };
|
|
/******/ for (var name in require) {
|
|
/******/ if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
|
|
/******/ Object.defineProperty(fn, name, createPropertyDescriptor(name));
|
|
/******/ }
|
|
/******/ }
|
|
/******/ fn.e = function (chunkId) {
|
|
/******/ return trackBlockingPromise(require.e(chunkId));
|
|
/******/ };
|
|
/******/ return fn;
|
|
/******/ }
|
|
/******/
|
|
/******/ function createModuleHotObject(moduleId, me) {
|
|
/******/ var _main = currentChildModule !== moduleId;
|
|
/******/ var hot = {
|
|
/******/ // private stuff
|
|
/******/ _acceptedDependencies: {},
|
|
/******/ _acceptedErrorHandlers: {},
|
|
/******/ _declinedDependencies: {},
|
|
/******/ _selfAccepted: false,
|
|
/******/ _selfDeclined: false,
|
|
/******/ _selfInvalidated: false,
|
|
/******/ _disposeHandlers: [],
|
|
/******/ _main: _main,
|
|
/******/ _requireSelf: function () {
|
|
/******/ currentParents = me.parents.slice();
|
|
/******/ currentChildModule = _main ? undefined : moduleId;
|
|
/******/ __webpack_require__(moduleId);
|
|
/******/ },
|
|
/******/
|
|
/******/ // Module API
|
|
/******/ active: true,
|
|
/******/ accept: function (dep, callback, errorHandler) {
|
|
/******/ if (dep === undefined) hot._selfAccepted = true;
|
|
/******/ else if (typeof dep === "function") hot._selfAccepted = dep;
|
|
/******/ else if (typeof dep === "object" && dep !== null) {
|
|
/******/ for (var i = 0; i < dep.length; i++) {
|
|
/******/ hot._acceptedDependencies[dep[i]] = callback || function () {};
|
|
/******/ hot._acceptedErrorHandlers[dep[i]] = errorHandler;
|
|
/******/ }
|
|
/******/ } else {
|
|
/******/ hot._acceptedDependencies[dep] = callback || function () {};
|
|
/******/ hot._acceptedErrorHandlers[dep] = errorHandler;
|
|
/******/ }
|
|
/******/ },
|
|
/******/ decline: function (dep) {
|
|
/******/ if (dep === undefined) hot._selfDeclined = true;
|
|
/******/ else if (typeof dep === "object" && dep !== null)
|
|
/******/ for (var i = 0; i < dep.length; i++)
|
|
/******/ hot._declinedDependencies[dep[i]] = true;
|
|
/******/ else hot._declinedDependencies[dep] = true;
|
|
/******/ },
|
|
/******/ dispose: function (callback) {
|
|
/******/ hot._disposeHandlers.push(callback);
|
|
/******/ },
|
|
/******/ addDisposeHandler: function (callback) {
|
|
/******/ hot._disposeHandlers.push(callback);
|
|
/******/ },
|
|
/******/ removeDisposeHandler: function (callback) {
|
|
/******/ var idx = hot._disposeHandlers.indexOf(callback);
|
|
/******/ if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
|
|
/******/ },
|
|
/******/ invalidate: function () {
|
|
/******/ this._selfInvalidated = true;
|
|
/******/ switch (currentStatus) {
|
|
/******/ case "idle":
|
|
/******/ currentUpdateApplyHandlers = [];
|
|
/******/ Object.keys(__webpack_require__.hmrI).forEach(function (key) {
|
|
/******/ __webpack_require__.hmrI[key](
|
|
/******/ moduleId,
|
|
/******/ currentUpdateApplyHandlers
|
|
/******/ );
|
|
/******/ });
|
|
/******/ setStatus("ready");
|
|
/******/ break;
|
|
/******/ case "ready":
|
|
/******/ Object.keys(__webpack_require__.hmrI).forEach(function (key) {
|
|
/******/ __webpack_require__.hmrI[key](
|
|
/******/ moduleId,
|
|
/******/ currentUpdateApplyHandlers
|
|
/******/ );
|
|
/******/ });
|
|
/******/ break;
|
|
/******/ case "prepare":
|
|
/******/ case "check":
|
|
/******/ case "dispose":
|
|
/******/ case "apply":
|
|
/******/ (queuedInvalidatedModules = queuedInvalidatedModules || []).push(
|
|
/******/ moduleId
|
|
/******/ );
|
|
/******/ break;
|
|
/******/ default:
|
|
/******/ // ignore requests in error states
|
|
/******/ break;
|
|
/******/ }
|
|
/******/ },
|
|
/******/
|
|
/******/ // Management API
|
|
/******/ check: hotCheck,
|
|
/******/ apply: hotApply,
|
|
/******/ status: function (l) {
|
|
/******/ if (!l) return currentStatus;
|
|
/******/ registeredStatusHandlers.push(l);
|
|
/******/ },
|
|
/******/ addStatusHandler: function (l) {
|
|
/******/ registeredStatusHandlers.push(l);
|
|
/******/ },
|
|
/******/ removeStatusHandler: function (l) {
|
|
/******/ var idx = registeredStatusHandlers.indexOf(l);
|
|
/******/ if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
|
|
/******/ },
|
|
/******/
|
|
/******/ //inherit from previous dispose call
|
|
/******/ data: currentModuleData[moduleId]
|
|
/******/ };
|
|
/******/ currentChildModule = undefined;
|
|
/******/ return hot;
|
|
/******/ }
|
|
/******/
|
|
/******/ function setStatus(newStatus) {
|
|
/******/ currentStatus = newStatus;
|
|
/******/ var results = [];
|
|
/******/
|
|
/******/ for (var i = 0; i < registeredStatusHandlers.length; i++)
|
|
/******/ results[i] = registeredStatusHandlers[i].call(null, newStatus);
|
|
/******/
|
|
/******/ return Promise.all(results);
|
|
/******/ }
|
|
/******/
|
|
/******/ function unblock() {
|
|
/******/ if (--blockingPromises === 0) {
|
|
/******/ setStatus("ready").then(function () {
|
|
/******/ if (blockingPromises === 0) {
|
|
/******/ var list = blockingPromisesWaiting;
|
|
/******/ blockingPromisesWaiting = [];
|
|
/******/ for (var i = 0; i < list.length; i++) {
|
|
/******/ list[i]();
|
|
/******/ }
|
|
/******/ }
|
|
/******/ });
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ function trackBlockingPromise(promise) {
|
|
/******/ switch (currentStatus) {
|
|
/******/ case "ready":
|
|
/******/ setStatus("prepare");
|
|
/******/ /* fallthrough */
|
|
/******/ case "prepare":
|
|
/******/ blockingPromises++;
|
|
/******/ promise.then(unblock, unblock);
|
|
/******/ return promise;
|
|
/******/ default:
|
|
/******/ return promise;
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ function waitForBlockingPromises(fn) {
|
|
/******/ if (blockingPromises === 0) return fn();
|
|
/******/ return new Promise(function (resolve) {
|
|
/******/ blockingPromisesWaiting.push(function () {
|
|
/******/ resolve(fn());
|
|
/******/ });
|
|
/******/ });
|
|
/******/ }
|
|
/******/
|
|
/******/ function hotCheck(applyOnUpdate) {
|
|
/******/ if (currentStatus !== "idle") {
|
|
/******/ throw new Error("check() is only allowed in idle status");
|
|
/******/ }
|
|
/******/ return setStatus("check")
|
|
/******/ .then(__webpack_require__.hmrM)
|
|
/******/ .then(function (update) {
|
|
/******/ if (!update) {
|
|
/******/ return setStatus(applyInvalidatedModules() ? "ready" : "idle").then(
|
|
/******/ function () {
|
|
/******/ return null;
|
|
/******/ }
|
|
/******/ );
|
|
/******/ }
|
|
/******/
|
|
/******/ return setStatus("prepare").then(function () {
|
|
/******/ var updatedModules = [];
|
|
/******/ currentUpdateApplyHandlers = [];
|
|
/******/
|
|
/******/ return Promise.all(
|
|
/******/ Object.keys(__webpack_require__.hmrC).reduce(function (
|
|
/******/ promises,
|
|
/******/ key
|
|
/******/ ) {
|
|
/******/ __webpack_require__.hmrC[key](
|
|
/******/ update.c,
|
|
/******/ update.r,
|
|
/******/ update.m,
|
|
/******/ promises,
|
|
/******/ currentUpdateApplyHandlers,
|
|
/******/ updatedModules
|
|
/******/ );
|
|
/******/ return promises;
|
|
/******/ },
|
|
/******/ [])
|
|
/******/ ).then(function () {
|
|
/******/ return waitForBlockingPromises(function () {
|
|
/******/ if (applyOnUpdate) {
|
|
/******/ return internalApply(applyOnUpdate);
|
|
/******/ } else {
|
|
/******/ return setStatus("ready").then(function () {
|
|
/******/ return updatedModules;
|
|
/******/ });
|
|
/******/ }
|
|
/******/ });
|
|
/******/ });
|
|
/******/ });
|
|
/******/ });
|
|
/******/ }
|
|
/******/
|
|
/******/ function hotApply(options) {
|
|
/******/ if (currentStatus !== "ready") {
|
|
/******/ return Promise.resolve().then(function () {
|
|
/******/ throw new Error(
|
|
/******/ "apply() is only allowed in ready status (state: " +
|
|
/******/ currentStatus +
|
|
/******/ ")"
|
|
/******/ );
|
|
/******/ });
|
|
/******/ }
|
|
/******/ return internalApply(options);
|
|
/******/ }
|
|
/******/
|
|
/******/ function internalApply(options) {
|
|
/******/ options = options || {};
|
|
/******/
|
|
/******/ applyInvalidatedModules();
|
|
/******/
|
|
/******/ var results = currentUpdateApplyHandlers.map(function (handler) {
|
|
/******/ return handler(options);
|
|
/******/ });
|
|
/******/ currentUpdateApplyHandlers = undefined;
|
|
/******/
|
|
/******/ var errors = results
|
|
/******/ .map(function (r) {
|
|
/******/ return r.error;
|
|
/******/ })
|
|
/******/ .filter(Boolean);
|
|
/******/
|
|
/******/ if (errors.length > 0) {
|
|
/******/ return setStatus("abort").then(function () {
|
|
/******/ throw errors[0];
|
|
/******/ });
|
|
/******/ }
|
|
/******/
|
|
/******/ // Now in "dispose" phase
|
|
/******/ var disposePromise = setStatus("dispose");
|
|
/******/
|
|
/******/ results.forEach(function (result) {
|
|
/******/ if (result.dispose) result.dispose();
|
|
/******/ });
|
|
/******/
|
|
/******/ // Now in "apply" phase
|
|
/******/ var applyPromise = setStatus("apply");
|
|
/******/
|
|
/******/ var error;
|
|
/******/ var reportError = function (err) {
|
|
/******/ if (!error) error = err;
|
|
/******/ };
|
|
/******/
|
|
/******/ var outdatedModules = [];
|
|
/******/ results.forEach(function (result) {
|
|
/******/ if (result.apply) {
|
|
/******/ var modules = result.apply(reportError);
|
|
/******/ if (modules) {
|
|
/******/ for (var i = 0; i < modules.length; i++) {
|
|
/******/ outdatedModules.push(modules[i]);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ });
|
|
/******/
|
|
/******/ return Promise.all([disposePromise, applyPromise]).then(function () {
|
|
/******/ // handle errors in accept handlers and self accepted module load
|
|
/******/ if (error) {
|
|
/******/ return setStatus("fail").then(function () {
|
|
/******/ throw error;
|
|
/******/ });
|
|
/******/ }
|
|
/******/
|
|
/******/ if (queuedInvalidatedModules) {
|
|
/******/ return internalApply(options).then(function (list) {
|
|
/******/ outdatedModules.forEach(function (moduleId) {
|
|
/******/ if (list.indexOf(moduleId) < 0) list.push(moduleId);
|
|
/******/ });
|
|
/******/ return list;
|
|
/******/ });
|
|
/******/ }
|
|
/******/
|
|
/******/ return setStatus("idle").then(function () {
|
|
/******/ return outdatedModules;
|
|
/******/ });
|
|
/******/ });
|
|
/******/ }
|
|
/******/
|
|
/******/ function applyInvalidatedModules() {
|
|
/******/ if (queuedInvalidatedModules) {
|
|
/******/ if (!currentUpdateApplyHandlers) currentUpdateApplyHandlers = [];
|
|
/******/ Object.keys(__webpack_require__.hmrI).forEach(function (key) {
|
|
/******/ queuedInvalidatedModules.forEach(function (moduleId) {
|
|
/******/ __webpack_require__.hmrI[key](
|
|
/******/ moduleId,
|
|
/******/ currentUpdateApplyHandlers
|
|
/******/ );
|
|
/******/ });
|
|
/******/ });
|
|
/******/ queuedInvalidatedModules = undefined;
|
|
/******/ return true;
|
|
/******/ }
|
|
/******/ }
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/require chunk loading */
|
|
/******/ (() => {
|
|
/******/ // no baseURI
|
|
/******/
|
|
/******/ // object to store loaded chunks
|
|
/******/ // "1" means "loaded", otherwise not loaded yet
|
|
/******/ var installedChunks = __webpack_require__.hmrS_require = __webpack_require__.hmrS_require || {
|
|
/******/ "server": 1
|
|
/******/ };
|
|
/******/
|
|
/******/ // no on chunks loaded
|
|
/******/
|
|
/******/ // no chunk install function needed
|
|
/******/
|
|
/******/ // no chunk loading
|
|
/******/
|
|
/******/ // no external install chunk
|
|
/******/
|
|
/******/ function loadUpdateChunk(chunkId, updatedModulesList) {
|
|
/******/ var update = require("./" + __webpack_require__.hu(chunkId));
|
|
/******/ var updatedModules = update.modules;
|
|
/******/ var runtime = update.runtime;
|
|
/******/ for(var moduleId in updatedModules) {
|
|
/******/ if(__webpack_require__.o(updatedModules, moduleId)) {
|
|
/******/ currentUpdate[moduleId] = updatedModules[moduleId];
|
|
/******/ if(updatedModulesList) updatedModulesList.push(moduleId);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ if(runtime) currentUpdateRuntime.push(runtime);
|
|
/******/ }
|
|
/******/
|
|
/******/ var currentUpdateChunks;
|
|
/******/ var currentUpdate;
|
|
/******/ var currentUpdateRemovedChunks;
|
|
/******/ var currentUpdateRuntime;
|
|
/******/ function applyHandler(options) {
|
|
/******/ if (__webpack_require__.f) delete __webpack_require__.f.requireHmr;
|
|
/******/ currentUpdateChunks = undefined;
|
|
/******/ function getAffectedModuleEffects(updateModuleId) {
|
|
/******/ var outdatedModules = [updateModuleId];
|
|
/******/ var outdatedDependencies = {};
|
|
/******/
|
|
/******/ var queue = outdatedModules.map(function (id) {
|
|
/******/ return {
|
|
/******/ chain: [id],
|
|
/******/ id: id
|
|
/******/ };
|
|
/******/ });
|
|
/******/ while (queue.length > 0) {
|
|
/******/ var queueItem = queue.pop();
|
|
/******/ var moduleId = queueItem.id;
|
|
/******/ var chain = queueItem.chain;
|
|
/******/ var module = __webpack_require__.c[moduleId];
|
|
/******/ if (
|
|
/******/ !module ||
|
|
/******/ (module.hot._selfAccepted && !module.hot._selfInvalidated)
|
|
/******/ )
|
|
/******/ continue;
|
|
/******/ if (module.hot._selfDeclined) {
|
|
/******/ return {
|
|
/******/ type: "self-declined",
|
|
/******/ chain: chain,
|
|
/******/ moduleId: moduleId
|
|
/******/ };
|
|
/******/ }
|
|
/******/ if (module.hot._main) {
|
|
/******/ return {
|
|
/******/ type: "unaccepted",
|
|
/******/ chain: chain,
|
|
/******/ moduleId: moduleId
|
|
/******/ };
|
|
/******/ }
|
|
/******/ for (var i = 0; i < module.parents.length; i++) {
|
|
/******/ var parentId = module.parents[i];
|
|
/******/ var parent = __webpack_require__.c[parentId];
|
|
/******/ if (!parent) continue;
|
|
/******/ if (parent.hot._declinedDependencies[moduleId]) {
|
|
/******/ return {
|
|
/******/ type: "declined",
|
|
/******/ chain: chain.concat([parentId]),
|
|
/******/ moduleId: moduleId,
|
|
/******/ parentId: parentId
|
|
/******/ };
|
|
/******/ }
|
|
/******/ if (outdatedModules.indexOf(parentId) !== -1) continue;
|
|
/******/ if (parent.hot._acceptedDependencies[moduleId]) {
|
|
/******/ if (!outdatedDependencies[parentId])
|
|
/******/ outdatedDependencies[parentId] = [];
|
|
/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]);
|
|
/******/ continue;
|
|
/******/ }
|
|
/******/ delete outdatedDependencies[parentId];
|
|
/******/ outdatedModules.push(parentId);
|
|
/******/ queue.push({
|
|
/******/ chain: chain.concat([parentId]),
|
|
/******/ id: parentId
|
|
/******/ });
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ return {
|
|
/******/ type: "accepted",
|
|
/******/ moduleId: updateModuleId,
|
|
/******/ outdatedModules: outdatedModules,
|
|
/******/ outdatedDependencies: outdatedDependencies
|
|
/******/ };
|
|
/******/ }
|
|
/******/
|
|
/******/ function addAllToSet(a, b) {
|
|
/******/ for (var i = 0; i < b.length; i++) {
|
|
/******/ var item = b[i];
|
|
/******/ if (a.indexOf(item) === -1) a.push(item);
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ // at begin all updates modules are outdated
|
|
/******/ // the "outdated" status can propagate to parents if they don't accept the children
|
|
/******/ var outdatedDependencies = {};
|
|
/******/ var outdatedModules = [];
|
|
/******/ var appliedUpdate = {};
|
|
/******/
|
|
/******/ var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
|
|
/******/ console.warn(
|
|
/******/ "[HMR] unexpected require(" + module.id + ") to disposed module"
|
|
/******/ );
|
|
/******/ };
|
|
/******/
|
|
/******/ for (var moduleId in currentUpdate) {
|
|
/******/ if (__webpack_require__.o(currentUpdate, moduleId)) {
|
|
/******/ var newModuleFactory = currentUpdate[moduleId];
|
|
/******/ /** @type {TODO} */
|
|
/******/ var result;
|
|
/******/ if (newModuleFactory) {
|
|
/******/ result = getAffectedModuleEffects(moduleId);
|
|
/******/ } else {
|
|
/******/ result = {
|
|
/******/ type: "disposed",
|
|
/******/ moduleId: moduleId
|
|
/******/ };
|
|
/******/ }
|
|
/******/ /** @type {Error|false} */
|
|
/******/ var abortError = false;
|
|
/******/ var doApply = false;
|
|
/******/ var doDispose = false;
|
|
/******/ var chainInfo = "";
|
|
/******/ if (result.chain) {
|
|
/******/ chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
|
|
/******/ }
|
|
/******/ switch (result.type) {
|
|
/******/ case "self-declined":
|
|
/******/ if (options.onDeclined) options.onDeclined(result);
|
|
/******/ if (!options.ignoreDeclined)
|
|
/******/ abortError = new Error(
|
|
/******/ "Aborted because of self decline: " +
|
|
/******/ result.moduleId +
|
|
/******/ chainInfo
|
|
/******/ );
|
|
/******/ break;
|
|
/******/ case "declined":
|
|
/******/ if (options.onDeclined) options.onDeclined(result);
|
|
/******/ if (!options.ignoreDeclined)
|
|
/******/ abortError = new Error(
|
|
/******/ "Aborted because of declined dependency: " +
|
|
/******/ result.moduleId +
|
|
/******/ " in " +
|
|
/******/ result.parentId +
|
|
/******/ chainInfo
|
|
/******/ );
|
|
/******/ break;
|
|
/******/ case "unaccepted":
|
|
/******/ if (options.onUnaccepted) options.onUnaccepted(result);
|
|
/******/ if (!options.ignoreUnaccepted)
|
|
/******/ abortError = new Error(
|
|
/******/ "Aborted because " + moduleId + " is not accepted" + chainInfo
|
|
/******/ );
|
|
/******/ break;
|
|
/******/ case "accepted":
|
|
/******/ if (options.onAccepted) options.onAccepted(result);
|
|
/******/ doApply = true;
|
|
/******/ break;
|
|
/******/ case "disposed":
|
|
/******/ if (options.onDisposed) options.onDisposed(result);
|
|
/******/ doDispose = true;
|
|
/******/ break;
|
|
/******/ default:
|
|
/******/ throw new Error("Unexception type " + result.type);
|
|
/******/ }
|
|
/******/ if (abortError) {
|
|
/******/ return {
|
|
/******/ error: abortError
|
|
/******/ };
|
|
/******/ }
|
|
/******/ if (doApply) {
|
|
/******/ appliedUpdate[moduleId] = newModuleFactory;
|
|
/******/ addAllToSet(outdatedModules, result.outdatedModules);
|
|
/******/ for (moduleId in result.outdatedDependencies) {
|
|
/******/ if (__webpack_require__.o(result.outdatedDependencies, moduleId)) {
|
|
/******/ if (!outdatedDependencies[moduleId])
|
|
/******/ outdatedDependencies[moduleId] = [];
|
|
/******/ addAllToSet(
|
|
/******/ outdatedDependencies[moduleId],
|
|
/******/ result.outdatedDependencies[moduleId]
|
|
/******/ );
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ if (doDispose) {
|
|
/******/ addAllToSet(outdatedModules, [result.moduleId]);
|
|
/******/ appliedUpdate[moduleId] = warnUnexpectedRequire;
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ currentUpdate = undefined;
|
|
/******/
|
|
/******/ // Store self accepted outdated modules to require them later by the module system
|
|
/******/ var outdatedSelfAcceptedModules = [];
|
|
/******/ for (var j = 0; j < outdatedModules.length; j++) {
|
|
/******/ var outdatedModuleId = outdatedModules[j];
|
|
/******/ var module = __webpack_require__.c[outdatedModuleId];
|
|
/******/ if (
|
|
/******/ module &&
|
|
/******/ (module.hot._selfAccepted || module.hot._main) &&
|
|
/******/ // removed self-accepted modules should not be required
|
|
/******/ appliedUpdate[outdatedModuleId] !== warnUnexpectedRequire &&
|
|
/******/ // when called invalidate self-accepting is not possible
|
|
/******/ !module.hot._selfInvalidated
|
|
/******/ ) {
|
|
/******/ outdatedSelfAcceptedModules.push({
|
|
/******/ module: outdatedModuleId,
|
|
/******/ require: module.hot._requireSelf,
|
|
/******/ errorHandler: module.hot._selfAccepted
|
|
/******/ });
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ var moduleOutdatedDependencies;
|
|
/******/
|
|
/******/ return {
|
|
/******/ dispose: function () {
|
|
/******/ currentUpdateRemovedChunks.forEach(function (chunkId) {
|
|
/******/ delete installedChunks[chunkId];
|
|
/******/ });
|
|
/******/ currentUpdateRemovedChunks = undefined;
|
|
/******/
|
|
/******/ var idx;
|
|
/******/ var queue = outdatedModules.slice();
|
|
/******/ while (queue.length > 0) {
|
|
/******/ var moduleId = queue.pop();
|
|
/******/ var module = __webpack_require__.c[moduleId];
|
|
/******/ if (!module) continue;
|
|
/******/
|
|
/******/ var data = {};
|
|
/******/
|
|
/******/ // Call dispose handlers
|
|
/******/ var disposeHandlers = module.hot._disposeHandlers;
|
|
/******/ for (j = 0; j < disposeHandlers.length; j++) {
|
|
/******/ disposeHandlers[j].call(null, data);
|
|
/******/ }
|
|
/******/ __webpack_require__.hmrD[moduleId] = data;
|
|
/******/
|
|
/******/ // disable module (this disables requires from this module)
|
|
/******/ module.hot.active = false;
|
|
/******/
|
|
/******/ // remove module from cache
|
|
/******/ delete __webpack_require__.c[moduleId];
|
|
/******/
|
|
/******/ // when disposing there is no need to call dispose handler
|
|
/******/ delete outdatedDependencies[moduleId];
|
|
/******/
|
|
/******/ // remove "parents" references from all children
|
|
/******/ for (j = 0; j < module.children.length; j++) {
|
|
/******/ var child = __webpack_require__.c[module.children[j]];
|
|
/******/ if (!child) continue;
|
|
/******/ idx = child.parents.indexOf(moduleId);
|
|
/******/ if (idx >= 0) {
|
|
/******/ child.parents.splice(idx, 1);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ // remove outdated dependency from module children
|
|
/******/ var dependency;
|
|
/******/ for (var outdatedModuleId in outdatedDependencies) {
|
|
/******/ if (__webpack_require__.o(outdatedDependencies, outdatedModuleId)) {
|
|
/******/ module = __webpack_require__.c[outdatedModuleId];
|
|
/******/ if (module) {
|
|
/******/ moduleOutdatedDependencies =
|
|
/******/ outdatedDependencies[outdatedModuleId];
|
|
/******/ for (j = 0; j < moduleOutdatedDependencies.length; j++) {
|
|
/******/ dependency = moduleOutdatedDependencies[j];
|
|
/******/ idx = module.children.indexOf(dependency);
|
|
/******/ if (idx >= 0) module.children.splice(idx, 1);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ },
|
|
/******/ apply: function (reportError) {
|
|
/******/ // insert new code
|
|
/******/ for (var updateModuleId in appliedUpdate) {
|
|
/******/ if (__webpack_require__.o(appliedUpdate, updateModuleId)) {
|
|
/******/ __webpack_require__.m[updateModuleId] = appliedUpdate[updateModuleId];
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ // run new runtime modules
|
|
/******/ for (var i = 0; i < currentUpdateRuntime.length; i++) {
|
|
/******/ currentUpdateRuntime[i](__webpack_require__);
|
|
/******/ }
|
|
/******/
|
|
/******/ // call accept handlers
|
|
/******/ for (var outdatedModuleId in outdatedDependencies) {
|
|
/******/ if (__webpack_require__.o(outdatedDependencies, outdatedModuleId)) {
|
|
/******/ var module = __webpack_require__.c[outdatedModuleId];
|
|
/******/ if (module) {
|
|
/******/ moduleOutdatedDependencies =
|
|
/******/ outdatedDependencies[outdatedModuleId];
|
|
/******/ var callbacks = [];
|
|
/******/ var errorHandlers = [];
|
|
/******/ var dependenciesForCallbacks = [];
|
|
/******/ for (var j = 0; j < moduleOutdatedDependencies.length; j++) {
|
|
/******/ var dependency = moduleOutdatedDependencies[j];
|
|
/******/ var acceptCallback =
|
|
/******/ module.hot._acceptedDependencies[dependency];
|
|
/******/ var errorHandler =
|
|
/******/ module.hot._acceptedErrorHandlers[dependency];
|
|
/******/ if (acceptCallback) {
|
|
/******/ if (callbacks.indexOf(acceptCallback) !== -1) continue;
|
|
/******/ callbacks.push(acceptCallback);
|
|
/******/ errorHandlers.push(errorHandler);
|
|
/******/ dependenciesForCallbacks.push(dependency);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ for (var k = 0; k < callbacks.length; k++) {
|
|
/******/ try {
|
|
/******/ callbacks[k].call(null, moduleOutdatedDependencies);
|
|
/******/ } catch (err) {
|
|
/******/ if (typeof errorHandlers[k] === "function") {
|
|
/******/ try {
|
|
/******/ errorHandlers[k](err, {
|
|
/******/ moduleId: outdatedModuleId,
|
|
/******/ dependencyId: dependenciesForCallbacks[k]
|
|
/******/ });
|
|
/******/ } catch (err2) {
|
|
/******/ if (options.onErrored) {
|
|
/******/ options.onErrored({
|
|
/******/ type: "accept-error-handler-errored",
|
|
/******/ moduleId: outdatedModuleId,
|
|
/******/ dependencyId: dependenciesForCallbacks[k],
|
|
/******/ error: err2,
|
|
/******/ originalError: err
|
|
/******/ });
|
|
/******/ }
|
|
/******/ if (!options.ignoreErrored) {
|
|
/******/ reportError(err2);
|
|
/******/ reportError(err);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ } else {
|
|
/******/ if (options.onErrored) {
|
|
/******/ options.onErrored({
|
|
/******/ type: "accept-errored",
|
|
/******/ moduleId: outdatedModuleId,
|
|
/******/ dependencyId: dependenciesForCallbacks[k],
|
|
/******/ error: err
|
|
/******/ });
|
|
/******/ }
|
|
/******/ if (!options.ignoreErrored) {
|
|
/******/ reportError(err);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ // Load self accepted modules
|
|
/******/ for (var o = 0; o < outdatedSelfAcceptedModules.length; o++) {
|
|
/******/ var item = outdatedSelfAcceptedModules[o];
|
|
/******/ var moduleId = item.module;
|
|
/******/ try {
|
|
/******/ item.require(moduleId);
|
|
/******/ } catch (err) {
|
|
/******/ if (typeof item.errorHandler === "function") {
|
|
/******/ try {
|
|
/******/ item.errorHandler(err, {
|
|
/******/ moduleId: moduleId,
|
|
/******/ module: __webpack_require__.c[moduleId]
|
|
/******/ });
|
|
/******/ } catch (err2) {
|
|
/******/ if (options.onErrored) {
|
|
/******/ options.onErrored({
|
|
/******/ type: "self-accept-error-handler-errored",
|
|
/******/ moduleId: moduleId,
|
|
/******/ error: err2,
|
|
/******/ originalError: err
|
|
/******/ });
|
|
/******/ }
|
|
/******/ if (!options.ignoreErrored) {
|
|
/******/ reportError(err2);
|
|
/******/ reportError(err);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ } else {
|
|
/******/ if (options.onErrored) {
|
|
/******/ options.onErrored({
|
|
/******/ type: "self-accept-errored",
|
|
/******/ moduleId: moduleId,
|
|
/******/ error: err
|
|
/******/ });
|
|
/******/ }
|
|
/******/ if (!options.ignoreErrored) {
|
|
/******/ reportError(err);
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/ }
|
|
/******/
|
|
/******/ return outdatedModules;
|
|
/******/ }
|
|
/******/ };
|
|
/******/ }
|
|
/******/ __webpack_require__.hmrI.require = function (moduleId, applyHandlers) {
|
|
/******/ if (!currentUpdate) {
|
|
/******/ currentUpdate = {};
|
|
/******/ currentUpdateRuntime = [];
|
|
/******/ currentUpdateRemovedChunks = [];
|
|
/******/ applyHandlers.push(applyHandler);
|
|
/******/ }
|
|
/******/ if (!__webpack_require__.o(currentUpdate, moduleId)) {
|
|
/******/ currentUpdate[moduleId] = __webpack_require__.m[moduleId];
|
|
/******/ }
|
|
/******/ };
|
|
/******/ __webpack_require__.hmrC.require = function (
|
|
/******/ chunkIds,
|
|
/******/ removedChunks,
|
|
/******/ removedModules,
|
|
/******/ promises,
|
|
/******/ applyHandlers,
|
|
/******/ updatedModulesList
|
|
/******/ ) {
|
|
/******/ applyHandlers.push(applyHandler);
|
|
/******/ currentUpdateChunks = {};
|
|
/******/ currentUpdateRemovedChunks = removedChunks;
|
|
/******/ currentUpdate = removedModules.reduce(function (obj, key) {
|
|
/******/ obj[key] = false;
|
|
/******/ return obj;
|
|
/******/ }, {});
|
|
/******/ currentUpdateRuntime = [];
|
|
/******/ chunkIds.forEach(function (chunkId) {
|
|
/******/ if (
|
|
/******/ __webpack_require__.o(installedChunks, chunkId) &&
|
|
/******/ installedChunks[chunkId] !== undefined
|
|
/******/ ) {
|
|
/******/ promises.push(loadUpdateChunk(chunkId, updatedModulesList));
|
|
/******/ currentUpdateChunks[chunkId] = true;
|
|
/******/ } else {
|
|
/******/ currentUpdateChunks[chunkId] = false;
|
|
/******/ }
|
|
/******/ });
|
|
/******/ if (__webpack_require__.f) {
|
|
/******/ __webpack_require__.f.requireHmr = function (chunkId, promises) {
|
|
/******/ if (
|
|
/******/ currentUpdateChunks &&
|
|
/******/ __webpack_require__.o(currentUpdateChunks, chunkId) &&
|
|
/******/ !currentUpdateChunks[chunkId]
|
|
/******/ ) {
|
|
/******/ promises.push(loadUpdateChunk(chunkId));
|
|
/******/ currentUpdateChunks[chunkId] = true;
|
|
/******/ }
|
|
/******/ };
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ __webpack_require__.hmrM = function() {
|
|
/******/ return Promise.resolve().then(function() {
|
|
/******/ return require("./" + __webpack_require__.hmrF());
|
|
/******/ })['catch'](function(err) { if(err.code !== 'MODULE_NOT_FOUND') throw err; });
|
|
/******/ }
|
|
/******/ })();
|
|
/******/
|
|
/************************************************************************/
|
|
/******/
|
|
/******/ // module cache are used so entry inlining is disabled
|
|
/******/ // startup
|
|
/******/ // Load entry module and return exports
|
|
/******/ var __webpack_exports__ = __webpack_require__("./src/lib/server/server.ts");
|
|
/******/
|
|
/******/ return __webpack_exports__;
|
|
/******/ })()
|
|
;
|
|
});
|
|
//# sourceMappingURL=server.js.map
|