@prostojs/mate 0.3.3 → 0.5.0

package/dist/index.mjs

@@ -0,0 +1,236 @@
+//#region src/module-identity.ts
+const MATE_MODULE_IDENTITY_KEY = Symbol.for("prostojs:mate:module-identity");
+function getModulePath() {
+	try {
+		return import.meta.url;
+	} catch {
+		return;
+	}
+}
+function formatIdentity(identity) {
+	const version = identity.version ? `v${identity.version}` : "unknown version";
+	return identity.path ? `${version} at ${identity.path}` : version;
+}
+/**
+* Stamps `globalThis` with this copy's identity and warns if another
+* copy of @prostojs/mate was already loaded.
+*
+* Invoked once at module scope from index.ts, so importing the package
+* performs the check.
+*/
+function warnOnDuplicateMate() {
+	const g = globalThis;
+	const identity = {};
+	identity.version = "0.4.0";
+	const path = getModulePath();
+	if (path) identity.path = path;
+	const first = g[MATE_MODULE_IDENTITY_KEY];
+	if (first) console.warn(`[mate] A second copy of @prostojs/mate was loaded (${formatIdentity(first)}, now ${formatIdentity(identity)}). Decorator metadata is stored per-copy and will NOT be visible across copies. Check your bundler/dedupe settings.`);
+	else g[MATE_MODULE_IDENTITY_KEY] = identity;
+}
+
+//#endregion
+//#region src/utils/helpers.ts
+function getConstructor(instance) {
+	return isConstructor(instance) ? instance : instance.constructor ? instance.constructor : Object.getPrototypeOf(instance).constructor;
+}
+function isConstructor(v) {
+	return typeof v === "function" && Object.getOwnPropertyDescriptor(v, "prototype") !== void 0 && Object.getOwnPropertyDescriptor(v, "caller") === void 0 && !!v.name;
+}
+
+//#endregion
+//#region src/reflect.ts
+let classMetadata = /* @__PURE__ */ new WeakMap();
+let paramMetadata = /* @__PURE__ */ new WeakMap();
+const root = typeof global === "object" ? global : typeof self === "object" ? self : {};
+function getMetaObject(target, prop) {
+	const isParam = typeof prop !== "undefined";
+	const metadata = isParam ? paramMetadata : classMetadata;
+	const targetKey = getConstructor(target);
+	let meta = metadata.get(targetKey);
+	if (!meta) {
+		meta = {};
+		metadata.set(targetKey, meta);
+	}
+	if (isParam) meta = meta[prop] = meta[prop] || {};
+	return meta;
+}
+const _reflect = {
+	getOwnMetadata(key, target, prop) {
+		return getMetaObject(target, prop)[key];
+	},
+	defineMetadata(key, data, target, prop) {
+		const meta = getMetaObject(target, prop);
+		meta[key] = data;
+	},
+	metadata(key, data) {
+		return ((target, propKey) => {
+			Reflect$1.defineMetadata(key, data, target, propKey);
+		});
+	},
+	_cleanup: (() => {
+		classMetadata = /* @__PURE__ */ new WeakMap();
+		paramMetadata = /* @__PURE__ */ new WeakMap();
+	})
+};
+if (!root.Reflect) root.Reflect = _reflect;
+else {
+	const funcs = [
+		"getOwnMetadata",
+		"defineMetadata",
+		"metadata"
+	];
+	const target = root.Reflect;
+	for (const func of funcs) if (typeof target[func] !== "function") Object.defineProperty(target, func, {
+		configurable: true,
+		writable: true,
+		value: _reflect[func]
+	});
+}
+const Reflect$1 = _reflect;
+
+//#endregion
+//#region src/mate.ts
+const Reflect = global?.Reflect || self?.Reflect || Reflect$1;
+var Mate = class {
+	constructor(workspace, options = {}) {
+		this.workspace = workspace;
+		this.options = options;
+		this.logger = options.logger || console;
+	}
+	/**
+	* Cleanup function to reset metadata
+	*
+	* It is usefull in dev mode when server restarts
+	*/
+	_cleanup() {
+		Reflect._cleanup?.call(Reflect);
+		this._readCache = void 0;
+	}
+	set(args, key, value, isArray) {
+		this._readCache = void 0;
+		let level = "CLASS";
+		const newArgs = args.level === "CLASS" ? { target: getConstructor(args.target) } : args.level === "PROP" ? {
+			target: args.target,
+			propKey: args.propKey
+		} : args;
+		let meta = Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {};
+		if (newArgs.propKey && this.options.readReturnType && !meta.returnType && args.descriptor) meta.returnType = Reflect.getOwnMetadata("design:returntype", newArgs.target, newArgs.propKey);
+		if (newArgs.propKey && this.options.readType && !meta.type) meta.type = Reflect.getOwnMetadata("design:type", newArgs.target, newArgs.propKey);
+		const { index } = newArgs;
+		const cb = typeof key === "function" ? key : void 0;
+		let data = meta;
+		if (!data.params) {
+			const paramTypes = Reflect.getOwnMetadata("design:paramtypes", newArgs.target, newArgs.propKey);
+			if (paramTypes) {
+				data.params = new Array(paramTypes.length);
+				for (let i = 0; i < paramTypes.length; i++) data.params[i] = { type: paramTypes[i] };
+			}
+		}
+		if (typeof index === "number") {
+			level = "PARAM";
+			data.params = data.params || [];
+			data.params[index] = data.params[index] || { type: void 0 };
+			if (cb) data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === "number" ? args.index : void 0);
+			else data = data.params[index];
+		} else if (!index && !args.descriptor && args.propKey && this.options.collectPropKeys && args.level !== "CLASS") this.set({
+			...args,
+			level: "CLASS"
+		}, (meta) => {
+			if (!meta.properties) meta.properties = [args.propKey];
+			else if (!meta.properties.includes(args.propKey)) meta.properties.push(args.propKey);
+			return meta;
+		});
+		level = typeof index === "number" ? "PARAM" : newArgs.propKey && newArgs.descriptor ? "METHOD" : newArgs.propKey ? "PROP" : "CLASS";
+		if (typeof key !== "function") if (isArray) {
+			const newArray = data[key] || [];
+			if (!Array.isArray(newArray))
+ /* istanbul ignore next line */
+			this.logger.error("Mate.add (isArray=true) called for non-array metadata");
+			newArray.unshift(value);
+			data[key] = newArray;
+		} else data[key] = value;
+		else if (cb && typeof index !== "number") meta = cb(data, level, args.propKey, typeof args.index === "number" ? args.index : void 0);
+		Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
+	}
+	read(target, propKey) {
+		const constructor = isConstructor(target) ? target : getConstructor(target);
+		const proto = constructor.prototype;
+		const propKeyStr = propKey;
+		const ctorCache = this._readCache?.get(constructor);
+		if (ctorCache?.has(propKeyStr)) return ctorCache.get(propKeyStr);
+		let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === "string" ? proto : constructor, propKey);
+		if (ownMeta && propKey === void 0 && ownMeta.params === void 0) {
+			const parent = Object.getPrototypeOf(constructor);
+			if (typeof parent === "function" && parent !== fnProto && parent !== constructor) ownMeta.params = this.read(parent)?.params;
+		}
+		if (this.options.inherit) {
+			const inheritFn = typeof this.options.inherit === "function" ? this.options.inherit : void 0;
+			let shouldInherit = this.options.inherit;
+			if (inheritFn) if (typeof propKey === "string") shouldInherit = inheritFn(Reflect.getOwnMetadata(this.workspace, constructor), ownMeta, "PROP", propKey);
+			else shouldInherit = inheritFn(ownMeta, ownMeta, "CLASS");
+			if (shouldInherit) {
+				const parent = Object.getPrototypeOf(constructor);
+				if (typeof parent === "function" && parent !== fnProto && parent !== constructor) {
+					const inheritedMeta = this.read(parent, propKey) || {};
+					const ownParams = ownMeta?.params;
+					ownMeta = {
+						...inheritedMeta,
+						...ownMeta
+					};
+					if (typeof propKey === "string" && ownParams && inheritedMeta?.params) {
+						for (let i = 0; i < ownParams.length; i++) if (typeof inheritedMeta?.params[i] !== "undefined") {
+							const ownParam = ownParams[i];
+							if (ownMeta.params && inheritFn && inheritFn(ownMeta, ownParam, "PARAM", typeof propKey === "string" ? propKey : void 0)) ownMeta.params[i] = {
+								...inheritedMeta?.params[i],
+								...ownParams[i]
+							};
+						}
+					}
+				}
+			}
+		}
+		const cache = this._readCache ??= /* @__PURE__ */ new WeakMap();
+		let tc = cache.get(constructor);
+		if (!tc) {
+			tc = /* @__PURE__ */ new Map();
+			cache.set(constructor, tc);
+		}
+		tc.set(propKeyStr, ownMeta);
+		return ownMeta;
+	}
+	apply(...decorators) {
+		return ((target, propKey, descriptor) => {
+			for (const d of decorators) d(target, propKey, descriptor);
+		});
+	}
+	decorate(key, value, isArray, level) {
+		return ((target, propKey, descriptor) => {
+			const args = {
+				target,
+				propKey,
+				descriptor: typeof descriptor === "number" ? void 0 : descriptor,
+				index: typeof descriptor === "number" ? descriptor : void 0,
+				level
+			};
+			this.set(args, key, value, isArray);
+		});
+	}
+	decorateConditional(ccb) {
+		return ((target, propKey, descriptor) => {
+			const d = ccb(typeof descriptor === "number" ? "PARAM" : propKey && descriptor ? "METHOD" : propKey ? "PROP" : "CLASS");
+			if (d) d(target, propKey, descriptor);
+		});
+	}
+	decorateClass(key, value, isArray) {
+		return this.decorate(key, value, isArray, "CLASS");
+	}
+};
+const fnProto = Object.getPrototypeOf(Function);
+
+//#endregion
+//#region src/index.ts
+warnOnDuplicateMate();
+
+//#endregion
+export { MATE_MODULE_IDENTITY_KEY, Mate, getConstructor, isConstructor, warnOnDuplicateMate };

package/package.json

@@ -1,81 +1,70 @@
 {
-  "name": "@prostojs/mate",
-  "version": "0.3.3",
-  "description": "MATE is TS Metadata Organizer",
-  "main": "index.js",
-  "module": "dist/mate.esm-bundler.js",
-  "types": "dist/mate.d.ts",
-  "files": [
-    "index.js",
-    "dist"
-  ],
-  "scripts": {
-    "build": "node ./scripts/build",
-    "release": "node ./scripts/release",
-    "test": "jest --runInBand",
-    "test:cov": "jest --runInBand --coverage",
-    "lint": "eslint --ext .ts src/**.ts --fix",
-    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
-    "version": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/prostojs/mate.git"
-  },
-  "keywords": [
-    "metadata",
-    "decorators",
-    "mate",
-    "prostojs"
-  ],
-  "buildOptions": {
-    "name": "ProstoMate",
-    "formats": [
-      "esm-bundler",
-      "cjs"
-    ]
-  },
-  "dependencies": {},
-  "gitHooks": {
-    "commit-msg": "node scripts/verifyCommit.js"
-  },
-  "author": "Artem Maltsev",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/prostojs/mate/issues"
-  },
-  "homepage": "https://github.com/prostojs/mate#readme",
-  "devDependencies": {
-    "@microsoft/api-extractor": "^7.30.0",
-    "@prostojs/dye": "^0.3.0",
-    "@rollup/plugin-commonjs": "^21.0.0",
-    "@rollup/plugin-node-resolve": "^13.0.6",
-    "@rollup/plugin-replace": "^3.0.0",
-    "@types/jest": "^27.5.2",
-    "@types/node": "^16.11.57",
-    "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
-    "brotli": "^1.3.3",
-    "conventional-changelog": "^3.1.24",
-    "conventional-changelog-cli": "^2.1.1",
-    "enquirer": "^2.3.6",
-    "eslint": "^7.32.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.24.2",
-    "execa": "^5.1.1",
-    "fs-extra": "^10.0.0",
-    "jest": "^27.2.5",
-    "minimist": "^1.2.6",
-    "reflect-metadata": "^0.1.13",
-    "rollup": "^2.58.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "semver": "^7.3.5",
-    "ts-jest": "^27.0.5",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.3.1",
-    "typescript": "^4.8.2",
-    "yorkie": "^2.0.0",
-    "zlib": "^1.0.5"
-  }
+    "name": "@prostojs/mate",
+    "version": "0.5.0",
+    "description": "MATE is TS Metadata Organizer",
+    "keywords": [
+        "decorators",
+        "mate",
+        "metadata",
+        "prostojs"
+    ],
+    "homepage": "https://github.com/prostojs/mate#readme",
+    "bugs": {
+        "url": "https://github.com/prostojs/mate/issues"
+    },
+    "license": "MIT",
+    "author": "Artem Maltsev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/prostojs/mate.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        },
+        "./package.json": "./package.json"
+    },
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json && rolldown -c rolldown.config.mjs && rm -rf dts-build",
+        "release": "node ./scripts/release",
+        "test": "vitest run",
+        "test:cov": "vitest run --coverage",
+        "lint": "oxlint",
+        "lint:fix": "oxlint --fix",
+        "format": "oxfmt",
+        "format:check": "oxfmt --check",
+        "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+        "version": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
+    },
+    "devDependencies": {
+        "@prostojs/dye": "^0.4.9",
+        "@swc/core": "^1.15.13",
+        "@types/node": "^22.19.11",
+        "conventional-changelog": "^3.1.25",
+        "conventional-changelog-cli": "^2.2.2",
+        "enquirer": "^2.4.1",
+        "execa": "^5.1.1",
+        "minimist": "^1.2.8",
+        "oxfmt": "^0.35.0",
+        "oxlint": "^1.50.0",
+        "reflect-metadata": "^0.1.14",
+        "rolldown": "1.0.0-rc.5",
+        "rolldown-plugin-dts": "^0.22.1",
+        "semver": "^7.7.4",
+        "typescript": "^5.9.3",
+        "unplugin-swc": "^1.5.9",
+        "vitest": "^3.2.4",
+        "yorkie": "^2.0.0"
+    },
+    "gitHooks": {
+        "commit-msg": "node scripts/verifyCommit.js"
+    }
 }

package/dist/mate.cjs.prod.js

@@ -1,263 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function getConstructor(instance) {
-    return isConstructor(instance) ?
-        instance : instance.constructor ?
-        instance.constructor : Object.getPrototypeOf(instance).constructor;
-}
-function isConstructor(v) {
-    return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
-}
-
-let classMetadata = new WeakMap();
-let paramMetadata = new WeakMap();
-const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
-function getMetaObject(target, prop) {
-    const isParam = typeof prop !== 'undefined';
-    const metadata = isParam ? paramMetadata : classMetadata;
-    const targetKey = getConstructor(target);
-    let meta = metadata.get(targetKey);
-    if (!meta) {
-        meta = {};
-        metadata.set(targetKey, meta);
-    }
-    if (isParam) {
-        meta = (meta[prop] =
-            meta[prop] || {});
-    }
-    return meta;
-}
-const _reflect = {
-    getOwnMetadata(key, target, prop) {
-        return getMetaObject(target, prop)[key];
-    },
-    defineMetadata(key, data, target, prop) {
-        const meta = getMetaObject(target, prop);
-        meta[key] = data;
-    },
-    metadata(key, data) {
-        return ((target, propKey) => {
-            Reflect$1.defineMetadata(key, data, target, propKey);
-        });
-    },
-    _cleanup: (() => {
-        classMetadata = new WeakMap();
-        paramMetadata = new WeakMap();
-    }),
-};
-if (!root.Reflect) {
-    root.Reflect = _reflect;
-}
-else {
-    const funcs = [
-        'getOwnMetadata',
-        'defineMetadata',
-        'metadata',
-    ];
-    const target = root.Reflect;
-    for (const func of funcs) {
-        if (typeof target[func] !== 'function') {
-            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
-        }
-    }
-}
-const Reflect$1 = _reflect;
-
-const Reflect = ((global === null || global === void 0 ? void 0 : global.Reflect) ||
-    (self === null || self === void 0 ? void 0 : self.Reflect) ||
-    Reflect$1);
-class Mate {
-    constructor(workspace, options = {}) {
-        this.workspace = workspace;
-        this.options = options;
-        this.logger = options.logger || console;
-    }
-    _cleanup() {
-        var _a;
-        (_a = Reflect._cleanup) === null || _a === void 0 ? void 0 : _a.call(Reflect);
-    }
-    set(args, key, value, isArray) {
-        var _a;
-        let level = 'CLASS';
-        const newArgs = args.level === 'CLASS'
-            ? { target: args.target }
-            : args.level === 'PROP'
-                ? { target: args.target, propKey: args.propKey }
-                : args;
-        let meta = (Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {});
-        if (newArgs.propKey &&
-            this.options.readReturnType &&
-            !meta.returnType &&
-            args.descriptor) {
-            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
-        }
-        if (newArgs.propKey && this.options.readType && !meta.type) {
-            meta.type = Reflect.getOwnMetadata('design:type', newArgs.target, newArgs.propKey);
-        }
-        const { index } = newArgs;
-        const cb = typeof key === 'function' ? key : undefined;
-        let data = meta;
-        if (!data.params) {
-            data.params = (_a = Reflect.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
-        }
-        if (typeof index === 'number') {
-            level = 'PARAM';
-            data.params = data.params || [];
-            data.params[index] = data.params[index] || {
-                type: undefined,
-            };
-            if (cb) {
-                data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-            }
-            else {
-                data = data.params[index];
-            }
-        }
-        else if (!index &&
-            !args.descriptor &&
-            args.propKey &&
-            this.options.collectPropKeys &&
-            args.level !== 'CLASS') {
-            this.set({ ...args, level: 'CLASS' }, (meta) => {
-                if (!meta.properties) {
-                    meta.properties = [args.propKey];
-                }
-                else if (!meta.properties.includes(args.propKey)) {
-                    meta.properties.push(args.propKey);
-                }
-                return meta;
-            });
-        }
-        level =
-            typeof index === 'number'
-                ? 'PARAM'
-                : newArgs.propKey && newArgs.descriptor
-                    ? 'METHOD'
-                    : newArgs.propKey
-                        ? 'PROP'
-                        : 'CLASS';
-        if (typeof key !== 'function') {
-            if (isArray) {
-                const newArray = (data[key] || []);
-                if (!Array.isArray(newArray)) {
-                    this.logger.error('Mate.add (isArray=true) called for non-array metadata');
-                }
-                newArray.unshift(value);
-                data[key] = newArray;
-            }
-            else {
-                data[key] = value;
-            }
-        }
-        else if (cb && typeof index !== 'number') {
-            meta = cb(data, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-        }
-        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
-    }
-    read(target, propKey) {
-        var _a;
-        const isConstr = isConstructor(target);
-        const constructor = isConstr ? target : getConstructor(target);
-        const proto = constructor.prototype;
-        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
-        if (ownMeta && propKey === undefined && ownMeta.params === undefined) {
-            const parent = Object.getPrototypeOf(constructor);
-            if (typeof parent === 'function' &&
-                parent !== fnProto &&
-                parent !== constructor) {
-                ownMeta.params = (_a = this.read(parent)) === null || _a === void 0 ? void 0 : _a.params;
-            }
-        }
-        if (this.options.inherit) {
-            const inheritFn = typeof this.options.inherit === 'function'
-                ? this.options.inherit
-                : undefined;
-            let shouldInherit = this.options.inherit;
-            if (inheritFn) {
-                if (typeof propKey === 'string') {
-                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
-                    shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
-                }
-                else {
-                    shouldInherit = inheritFn(ownMeta, ownMeta, 'CLASS');
-                }
-            }
-            if (shouldInherit) {
-                const parent = Object.getPrototypeOf(constructor);
-                if (typeof parent === 'function' &&
-                    parent !== fnProto &&
-                    parent !== constructor) {
-                    const inheritedMeta = (this.read(parent, propKey) ||
-                        {});
-                    const ownParams = ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params;
-                    ownMeta = { ...inheritedMeta, ...ownMeta };
-                    if (typeof propKey === 'string' &&
-                        ownParams &&
-                        (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params)) {
-                        for (let i = 0; i < ownParams.length; i++) {
-                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !== 'undefined') {
-                                const ownParam = ownParams[i];
-                                if (ownMeta.params &&
-                                    inheritFn &&
-                                    inheritFn(ownMeta, ownParam, 'PARAM', typeof propKey === 'string'
-                                        ? propKey
-                                        : undefined)) {
-                                    ownMeta.params[i] = {
-                                        ...inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i],
-                                        ...ownParams[i],
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return ownMeta;
-    }
-    apply(...decorators) {
-        return ((target, propKey, descriptor) => {
-            for (const d of decorators) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorate(key, value, isArray, level) {
-        return ((target, propKey, descriptor) => {
-            const args = {
-                target,
-                propKey,
-                descriptor: typeof descriptor === 'number' ? undefined : descriptor,
-                index: typeof descriptor === 'number' ? descriptor : undefined,
-                level,
-            };
-            this.set(args, key, value, isArray);
-        });
-    }
-    decorateConditional(ccb) {
-        return ((target, propKey, descriptor) => {
-            const hasIndex = typeof descriptor === 'number';
-            const decoratorLevel = hasIndex
-                ? 'PARAM'
-                : propKey && descriptor
-                    ? 'METHOD'
-                    : propKey
-                        ? 'PROP'
-                        : 'CLASS';
-            const d = ccb(decoratorLevel);
-            if (d) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorateClass(key, value, isArray) {
-        return this.decorate(key, value, isArray, 'CLASS');
-    }
-}
-const fnProto = Object.getPrototypeOf(Function);
-
-exports.Mate = Mate;
-exports.getConstructor = getConstructor;
-exports.isConstructor = isConstructor;