// 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 root = typeof globalThis === "object" ? globalThis :
+ typeof global === "object" ? global :
+ typeof self === "object" ? self :
+ typeof this === "object" ? this :
+ sloppyModeThis();
var exporter = makeExporter(Reflect);
+ if (typeof root.Reflect !== "undefined") {
+ exporter = makeExporter(root.Reflect, exporter);
+ }
+ factory(exporter, root);
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 });
- }
+ Object.defineProperty(target, key, { configurable: true, writable: true, value: value });
if (previous)
previous(key, value);
};
}
- })(function (exporter) {
+ function functionThis() {
+ try {
+ return Function("return this;")();
+ }
+ catch (_) { }
+ }
+ function indirectEvalThis() {
+ try {
+ return (void 0, eval)("(function() { return this; })()");
+ }
+ catch (_) { }
+ }
+ function sloppyModeThis() {
+ return functionThis() || indirectEvalThis();
+ }
+ })(function (exporter, root) {
var hasOwn = Object.prototype.hasOwnProperty;
// feature test for Symbol support
var supportsSymbol = typeof Symbol === "function";
};
// 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();
+ var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+ var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+ var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+ var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
+ var metadataRegistry = GetOrCreateMetadataRegistry();
+ var metadataProvider = CreateMetadataProvider(metadataRegistry);
/**
* Applies a set of decorators to a property of a target object.
* @param decorators An array of decorators.
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))
+ if (!IsObject(target))
+ throw new TypeError();
+ if (!IsUndefined(propertyKey))
+ propertyKey = ToPropertyKey(propertyKey);
+ var provider = GetMetadataProvider(target, propertyKey, /*Create*/ false);
+ if (IsUndefined(provider))
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;
+ return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
}
exporter("deleteMetadata", deleteMetadata);
function DecorateConstructor(decorators, target) {
}
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) {
// 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))
+ var provider = GetMetadataProvider(O, P, /*Create*/ false);
+ if (IsUndefined(provider))
return false;
- return ToBoolean(metadataMap.has(MetadataKey));
+ return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
}
// 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)
// https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata
// 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);
+ var provider = GetMetadataProvider(O, P, /*Create*/ false);
+ if (IsUndefined(provider))
+ return;
+ return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
}
// 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);
+ var provider = GetMetadataProvider(O, P, /*Create*/ true);
+ provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
}
// 3.1.6.1 OrdinaryMetadataKeys(O, P)
// https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys
// 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++;
+ var provider = GetMetadataProvider(O, P, /*create*/ false);
+ if (!provider) {
+ return [];
}
+ return provider.OrdinaryOwnMetadataKeys(O, P);
}
- // 6 ECMAScript Data Typ0es and Values
+ // 6 ECMAScript Data Types and Values
// https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
function Type(x) {
if (x === null)
default: return false;
}
}
+ function SameValueZero(x, y) {
+ return x === y || x !== x && y !== y;
+ }
// 7.3 Operations on Objects
// https://tc39.github.io/ecma262/#sec-operations-on-objects
// 7.3.9 GetMethod(V, P)
// we have a pretty good guess at the heritage.
return constructor;
}
+ // Global metadata registry
+ // - Allows `import "reflect-metadata"` and `import "reflect-metadata/no-conflict"` to interoperate.
+ // - Uses isolated metadata if `Reflect` is frozen before the registry can be installed.
+ /**
+ * Creates a registry used to allow multiple `reflect-metadata` providers.
+ */
+ function CreateMetadataRegistry() {
+ var fallback;
+ if (!IsUndefined(registrySymbol) &&
+ typeof root.Reflect !== "undefined" &&
+ !(registrySymbol in root.Reflect) &&
+ typeof root.Reflect.defineMetadata === "function") {
+ // interoperate with older version of `reflect-metadata` that did not support a registry.
+ fallback = CreateFallbackProvider(root.Reflect);
+ }
+ var first;
+ var second;
+ var rest;
+ var targetProviderMap = new _WeakMap();
+ var registry = {
+ registerProvider: registerProvider,
+ getProvider: getProvider,
+ setProvider: setProvider,
+ };
+ return registry;
+ function registerProvider(provider) {
+ if (!Object.isExtensible(registry)) {
+ throw new Error("Cannot add provider to a frozen registry.");
+ }
+ switch (true) {
+ case fallback === provider: break;
+ case IsUndefined(first):
+ first = provider;
+ break;
+ case first === provider: break;
+ case IsUndefined(second):
+ second = provider;
+ break;
+ case second === provider: break;
+ default:
+ if (rest === undefined)
+ rest = new _Set();
+ rest.add(provider);
+ break;
+ }
+ }
+ function getProviderNoCache(O, P) {
+ if (!IsUndefined(first)) {
+ if (first.isProviderFor(O, P))
+ return first;
+ if (!IsUndefined(second)) {
+ if (second.isProviderFor(O, P))
+ return first;
+ if (!IsUndefined(rest)) {
+ var iterator = GetIterator(rest);
+ while (true) {
+ var next = IteratorStep(iterator);
+ if (!next) {
+ return undefined;
+ }
+ var provider = IteratorValue(next);
+ if (provider.isProviderFor(O, P)) {
+ IteratorClose(iterator);
+ return provider;
+ }
+ }
+ }
+ }
+ }
+ if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+ return fallback;
+ }
+ return undefined;
+ }
+ function getProvider(O, P) {
+ var providerMap = targetProviderMap.get(O);
+ var provider;
+ if (!IsUndefined(providerMap)) {
+ provider = providerMap.get(P);
+ }
+ if (!IsUndefined(provider)) {
+ return provider;
+ }
+ provider = getProviderNoCache(O, P);
+ if (!IsUndefined(provider)) {
+ if (IsUndefined(providerMap)) {
+ providerMap = new _Map();
+ targetProviderMap.set(O, providerMap);
+ }
+ providerMap.set(P, provider);
+ }
+ return provider;
+ }
+ function hasProvider(provider) {
+ if (IsUndefined(provider))
+ throw new TypeError();
+ return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+ }
+ function setProvider(O, P, provider) {
+ if (!hasProvider(provider)) {
+ throw new Error("Metadata provider not registered.");
+ }
+ var existingProvider = getProvider(O, P);
+ if (existingProvider !== provider) {
+ if (!IsUndefined(existingProvider)) {
+ return false;
+ }
+ var providerMap = targetProviderMap.get(O);
+ if (IsUndefined(providerMap)) {
+ providerMap = new _Map();
+ targetProviderMap.set(O, providerMap);
+ }
+ providerMap.set(P, provider);
+ }
+ return true;
+ }
+ }
+ /**
+ * Gets or creates the shared registry of metadata providers.
+ */
+ function GetOrCreateMetadataRegistry() {
+ var metadataRegistry;
+ if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+ metadataRegistry = root.Reflect[registrySymbol];
+ }
+ if (IsUndefined(metadataRegistry)) {
+ metadataRegistry = CreateMetadataRegistry();
+ }
+ if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+ Object.defineProperty(root.Reflect, registrySymbol, {
+ enumerable: false,
+ configurable: false,
+ writable: false,
+ value: metadataRegistry
+ });
+ }
+ return metadataRegistry;
+ }
+ function CreateMetadataProvider(registry) {
+ // [[Metadata]] internal slot
+ // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots
+ var metadata = new _WeakMap();
+ var provider = {
+ isProviderFor: function (O, P) {
+ var targetMetadata = metadata.get(O);
+ if (IsUndefined(targetMetadata))
+ return false;
+ return targetMetadata.has(P);
+ },
+ OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata,
+ OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata,
+ OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata,
+ OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys,
+ OrdinaryDeleteMetadata: OrdinaryDeleteMetadata,
+ };
+ metadataRegistry.registerProvider(provider);
+ return provider;
+ function GetOrCreateMetadataMap(O, P, Create) {
+ var targetMetadata = metadata.get(O);
+ var createdTargetMetadata = false;
+ if (IsUndefined(targetMetadata)) {
+ if (!Create)
+ return undefined;
+ targetMetadata = new _Map();
+ metadata.set(O, targetMetadata);
+ createdTargetMetadata = true;
+ }
+ var metadataMap = targetMetadata.get(P);
+ if (IsUndefined(metadataMap)) {
+ if (!Create)
+ return undefined;
+ metadataMap = new _Map();
+ targetMetadata.set(P, metadataMap);
+ if (!registry.setProvider(O, P, provider)) {
+ targetMetadata.delete(P);
+ if (createdTargetMetadata) {
+ metadata.delete(O);
+ }
+ throw new Error("Wrong provider for target.");
+ }
+ }
+ return metadataMap;
+ }
+ // 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.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.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++;
+ }
+ }
+ function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+ var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
+ if (IsUndefined(metadataMap))
+ return false;
+ if (!metadataMap.delete(MetadataKey))
+ return false;
+ if (metadataMap.size === 0) {
+ var targetMetadata = metadata.get(O);
+ if (!IsUndefined(targetMetadata)) {
+ targetMetadata.delete(P);
+ if (targetMetadata.size === 0) {
+ metadata.delete(targetMetadata);
+ }
+ }
+ }
+ return true;
+ }
+ }
+ function CreateFallbackProvider(reflect) {
+ var defineMetadata = reflect.defineMetadata, hasOwnMetadata = reflect.hasOwnMetadata, getOwnMetadata = reflect.getOwnMetadata, getOwnMetadataKeys = reflect.getOwnMetadataKeys, deleteMetadata = reflect.deleteMetadata;
+ var metadataOwner = new _WeakMap();
+ var provider = {
+ isProviderFor: function (O, P) {
+ var metadataPropertySet = metadataOwner.get(O);
+ if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+ return true;
+ }
+ if (getOwnMetadataKeys(O, P).length) {
+ if (IsUndefined(metadataPropertySet)) {
+ metadataPropertySet = new _Set();
+ metadataOwner.set(O, metadataPropertySet);
+ }
+ metadataPropertySet.add(P);
+ return true;
+ }
+ return false;
+ },
+ OrdinaryDefineOwnMetadata: defineMetadata,
+ OrdinaryHasOwnMetadata: hasOwnMetadata,
+ OrdinaryGetOwnMetadata: getOwnMetadata,
+ OrdinaryOwnMetadataKeys: getOwnMetadataKeys,
+ OrdinaryDeleteMetadata: deleteMetadata,
+ };
+ return provider;
+ }
+ /**
+ * Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,
+ * then this module's metadata provider is assigned to the object.
+ */
+ function GetMetadataProvider(O, P, Create) {
+ var registeredProvider = metadataRegistry.getProvider(O, P);
+ if (!IsUndefined(registeredProvider)) {
+ return registeredProvider;
+ }
+ if (Create) {
+ if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+ return metadataProvider;
+ }
+ throw new Error("Illegal state.");
+ }
+ return undefined;
+ }
// naive Map shim
function CreateMapPolyfill() {
var cacheSentinel = {};
};
return MapIterator;
}());
- return /** @class */ (function () {
+ var Map = /** @class */ (function () {
function Map() {
this._keys = [];
this._values = [];
}
this._keys.length--;
this._values.length--;
- if (key === this._cacheKey) {
+ if (SameValueZero(key, this._cacheKey)) {
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
}
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 (!SameValueZero(this._cacheKey, key)) {
+ this._cacheIndex = -1;
+ for (var i = 0; i < this._keys.length; i++) {
+ if (SameValueZero(this._keys[i], key)) {
+ this._cacheIndex = i;
+ break;
+ }
+ }
}
if (this._cacheIndex < 0 && insert) {
this._cacheIndex = this._keys.length;
};
return Map;
}());
+ return Map;
function getKey(key, _) {
return key;
}
}
// naive Set shim
function CreateSetPolyfill() {
- return /** @class */ (function () {
+ var Set = /** @class */ (function () {
function Set() {
this._map = new _Map();
}
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.values = function () { return this._map.keys(); };
Set.prototype.entries = function () { return this._map.entries(); };
Set.prototype["@@iterator"] = function () { return this.keys(); };
Set.prototype[iteratorSymbol] = function () { return this.keys(); };
return Set;
}());
+ return Set;
}
// naive WeakMap shim
function CreateWeakMapPolyfill() {
}
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);
+ var array = new Uint8Array(size);
+ if (typeof crypto !== "undefined") {
+ crypto.getRandomValues(array);
+ }
+ else if (typeof msCrypto !== "undefined") {
+ msCrypto.getRandomValues(array);
+ }
+ else {
+ FillRandomBytes(array, size);
+ }
+ return array;
}
return FillRandomBytes(new Array(size), size);
}
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
-/* global global, define, Symbol, Reflect, Promise, SuppressedError */
+/* global global, define, Symbol, Reflect, Promise, SuppressedError, Iterator */
var __extends;
var __assign;
var __rest;
var __createBinding;
var __addDisposableResource;
var __disposeResources;
+var __rewriteRelativeImportExtension;
(function (factory) {
var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
if (typeof define === "function" && define.amd) {
};
__generator = function (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;
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+ return g.next = verb(0), g["throw"] = verb(1), g["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.");
__asyncGenerator = function (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); }); }; }
+ return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+ function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+ function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
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 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]); }
o["default"] = v;
};
+ var ownKeys = function(o) {
+ ownKeys = Object.getOwnPropertyNames || function (o) {
+ var ar = [];
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o);
+ };
+
__importStar = function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
__addDisposableResource = function (env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
- var dispose;
+ var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
+ if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+ if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
+ var r, s = 0;
function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = env.stack.pop()) {
try {
- var result = rec.dispose && rec.dispose.call(rec.value);
- if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
}
catch (e) {
fail(e);
}
}
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
};
+ __rewriteRelativeImportExtension = function (path, preserveJsx) {
+ if (typeof path === "string" && /^\.\.?\//.test(path)) {
+ return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+ return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+ });
+ }
+ return path;
+ };
+
exporter("__extends", __extends);
exporter("__assign", __assign);
exporter("__rest", __rest);
exporter("__classPrivateFieldIn", __classPrivateFieldIn);
exporter("__addDisposableResource", __addDisposableResource);
exporter("__disposeResources", __disposeResources);
+ exporter("__rewriteRelativeImportExtension", __rewriteRelativeImportExtension);
+});
+
+0 && (module.exports = {
+ __extends: __extends,
+ __assign: __assign,
+ __rest: __rest,
+ __decorate: __decorate,
+ __param: __param,
+ __esDecorate: __esDecorate,
+ __runInitializers: __runInitializers,
+ __propKey: __propKey,
+ __setFunctionName: __setFunctionName,
+ __metadata: __metadata,
+ __awaiter: __awaiter,
+ __generator: __generator,
+ __exportStar: __exportStar,
+ __createBinding: __createBinding,
+ __values: __values,
+ __read: __read,
+ __spread: __spread,
+ __spreadArrays: __spreadArrays,
+ __spreadArray: __spreadArray,
+ __await: __await,
+ __asyncGenerator: __asyncGenerator,
+ __asyncDelegator: __asyncDelegator,
+ __asyncValues: __asyncValues,
+ __makeTemplateObject: __makeTemplateObject,
+ __importStar: __importStar,
+ __importDefault: __importDefault,
+ __classPrivateFieldGet: __classPrivateFieldGet,
+ __classPrivateFieldSet: __classPrivateFieldSet,
+ __classPrivateFieldIn: __classPrivateFieldIn,
+ __addDisposableResource: __addDisposableResource,
+ __disposeResources: __disposeResources,
+ __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
});
projects / GitHub / WoltLab / WCF.git / commitdiff