@uql/core 3.1.2 → 3.1.3

package/CHANGELOG.md

@@ -3,9 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [3.1.2](https://github.com/rogerpadilla/uql/compare/@uql/core@3.1.1...@uql/core@3.1.2) (2025-12-30)
+## [3.1.3](https://github.com/rogerpadilla/uql/compare/@uql/core@3.1.2...@uql/core@3.1.3) (2025-12-30)
 
-**Note:** Version bump only for package @uql/core
+
+### Features
+
+* add migration CLI and update core package build configuration with new build config and declaration maps while removing old path aliases. ([2b87dd4](https://github.com/rogerpadilla/uql/commit/2b87dd411d05c9844b3e3a6b0a7c74d120b9c362))
+* Implement custom test coverage reporting and simplify README database adapter table. ([837fadf](https://github.com/rogerpadilla/uql/commit/837fadf2cfc27be3a16efc2c489f83c047cc24e1))
 
 
 

package/README.md

@@ -4,7 +4,7 @@
 
 [![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![coverage status](https://coveralls.io/repos/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/r/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
 
-[uql](https://uql.app) is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript, it is designed to be fast, safe, and easy to integrate into any application.
+[UQL](https://uql.app) is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript, it is designed to be fast, safe, and easy to integrate into any application.
 
 It can run in Node.js, Browser, React Native, Expo, Electron, Deno, Bun, and many more!
 
@@ -56,12 +56,12 @@ See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-or
 
 2. Install one of the specific adapters for your database:
 
-| Database     | Driver           | UQL Adapter    |
-| ------------ | ---------------- | ---------------- |
-| `PostgreSQL` | `pg`             | `uql-postgres` |
-| `SQLite`     | `better-sqlite3` | `uql-sqlite`   |
-| `MariaDB`    | `mariadb`        | `uql-maria`    |
-| `MySQL`      | `mysql2`         | `uql-mysql`    |
+| Database     | Driver
+| ------------ | ----------------
+| `PostgreSQL` | `pg`
+| `SQLite`     | `better-sqlite3`
+| `MariaDB`    | `mariadb`
+| `MySQL`      | `mysql2`
 
  
 
@@ -76,14 +76,12 @@ bun add pg
 3. Additionally, your `tsconfig.json` may need the following flags:
 
    ```json
-   "target": "es2022",
+   "target": "ES2024",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
    ```
 
- 
-
-> **Note**: UQL provides first-class support for **Bun**. It is recommended to use Bun for a significantly faster developer experience.
+> **Note**: `"ES2022"`, `"ES2023"`, or `"ESNext"` will also work fine for `target`.
 
 ---
 
@@ -91,11 +89,10 @@ bun add pg
 
 ## 2. Define the entities
 
-Annotate your classes with decorators from `uql/entity`. UQL supports detailed schema metadata for precise DDL generation.
+Annotate your classes with decorators from `@uql/core`. UQL supports detailed schema metadata for precise DDL generation.
 
 ```ts
-import { Entity, Id, Field, OneToOne, OneToMany, ManyToOne, ManyToMany } from '@uql/core/entity';
-import type { Relation } from '@uql/core/type';
+import { Entity, Id, Field, OneToOne, OneToMany, ManyToOne, ManyToMany, type Relation } from '@uql/core';
 
 @Entity()
 export class User {
@@ -179,7 +176,7 @@ A querier-pool can be set in any of the bootstrap files of your app (e.g. in the
 ```ts
 // file: ./shared/orm.ts
 import { SnakeCaseNamingStrategy } from '@uql/core';
-import { PgQuerierPool } from 'uql-postgres';
+import { PgQuerierPool } from '@uql/core/postgres';
 
 export const querierPool = new PgQuerierPool(
   {
@@ -212,7 +209,7 @@ UQL provides multiple ways to interact with your data, from low-level `Queriers`
 Repositories provide a clean, Data-Mapper style interface for your entities.
 
 ```ts
-import { GenericRepository } from '@uql/core/repository';
+import { GenericRepository } from '@uql/core';
 import { User } from './shared/models/index.js';
 import { querierPool } from './shared/orm.js';
 
@@ -231,7 +228,7 @@ try {
       tagsCount: true       // Virtual field (calculated at runtime)
     },
     $where: {
-      email: { $iincludes: '@uql/core' }, // Case-insensitive search
+      email: { $iincludes: '@example.com' }, // Case-insensitive search
       status: 'active'
     },
     $sort: { createdAt: -1 },
@@ -248,9 +245,9 @@ try {
 UQL's query syntax is context-aware. When you query a relation, the available fields and operators are automatically suggested and validated based on that related entity.
 
 ```ts
-import { GenericRepository } from '@uql/core/repository';
-import { User } from './shared/models/index.js';
+import { GenericRepository } from '@uql/core';
 import { querierPool } from './shared/orm.js';
+import { User } from './shared/models/index.js';
 
 const authorsWithPopularPosts = await querierPool.transaction(async (querier) => {
   const userRepository = new GenericRepository(User, querier);
@@ -285,8 +282,7 @@ const authorsWithPopularPosts = await querierPool.transaction(async (querier) =>
 Define complex logic directly in your entities using `raw` functions from `uql/util`. These are highly efficient as they are resolved during SQL generation.
 
 ```ts
-import { Entity, Id, Field } from '@uql/core/entity';
-import { raw } from '@uql/core/util';
+import { Entity, Id, Field, raw } from '@uql/core';
 import { ItemTag } from './shared/models/index.js';
 
 @Entity()
@@ -317,8 +313,8 @@ export class Item {
 UQL ensures your operations are serialized and thread-safe.
 
 ```ts
-import { User, Profile } from './shared/models/index.js';
 import { querierPool } from './shared/orm.js';
+import { User, Profile } from './shared/models/index.js';
 
 const result = await querierPool.transaction(async (querier) => {
   const user = await querier.findOne(User, { $where: { email: '...' } });
@@ -339,12 +335,11 @@ UQL includes a robust migration system and an "Entity-First" synchronization eng
 Create a `uql.config.ts` file in your project root:
 
 ```typescript
-import { PgQuerierPool } from 'uql-postgres';
-import { User, Post } from './src/entities/index.js';
+import { PgQuerierPool } from '@uql/core/postgres';
+import { User, Post } from './shared/models/index.js';
 
 export default {
   querierPool: new PgQuerierPool({ /* config */ }),
-  dialect: 'postgres',
   entities: [User, Post],
   migrationsPath: './migrations',
 };
@@ -408,6 +403,6 @@ For those who want to see the "engine under the hood," check out these resources
 - **Core Dialect Logic**: The foundation of our context-aware SQL generation in [abstractSqlDialect.ts](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/dialect/abstractSqlDialect.ts).
 - **Comprehensive Test Suite**:
   - [Abstract SQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/dialect/abstractSqlDialect-spec.ts): The base test suite shared by all dialects.
-  - [PostgreSQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/postgres/src/postgresDialect.spec.ts) | [MySQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/mysql/src/mysqlDialect.spec.ts) | [SQLite Spec](https://github.com/rogerpadilla/uql/blob/main/packages/sqlite/src/sqliteDialect.spec.ts).
+  - [PostgreSQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/postgres/postgresDialect.spec.ts) | [MySQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/mysql/mysqlDialect.spec.ts) | [SQLite Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/sqlite/sqliteDialect.spec.ts).
   - [Querier Integration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/querier/abstractSqlQuerier-spec.ts): Testing the interaction between SQL generation and connection management.
-  - [MongoDB Migration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/uql/src/migrate/migrator-mongo.it.ts): Integration tests ensuring correct collection and index synchronization for MongoDB.
+  - [MongoDB Migration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/migrate/migrator-mongo.it.ts): Integration tests ensuring correct collection and index synchronization for MongoDB.

package/dist/browser/cc-BEf4wTUm.js

@@ -0,0 +1,535 @@
+/* @minVersion 7.20.0 */ /**
+  Enums are used in this file, but not assigned to vars to avoid non-hoistable values
+
+  CONSTRUCTOR = 0;
+  PUBLIC = 1;
+  PRIVATE = 2;
+
+  FIELD = 0;
+  ACCESSOR = 1;
+  METHOD = 2;
+  GETTER = 3;
+  SETTER = 4;
+
+  STATIC = 5;
+
+  CLASS = 10; // only used in assertValidReturnValue
+*/ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1 /* ACCESSOR */ :
+                kindStr = "accessor";
+                break;
+            case 2 /* METHOD */ :
+                kindStr = "method";
+                break;
+            case 3 /* GETTER */ :
+                kindStr = "getter";
+                break;
+            case 4 /* SETTER */ :
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (kind === 0 /* FIELD */ ) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2 /* METHOD */ ) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            // replace with values that will go through the final getter and setter
+            if (kind === 1 /* ACCESSOR */  || kind === 3 /* GETTER */ ) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+            if (kind === 1 /* ACCESSOR */  || kind === 4 /* SETTER */ ) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (kind === 1 /* ACCESSOR */ ) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0 /* FIELD */ ) {
+                hint = "field";
+            } else if (kind === 10 /* CLASS */ ) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) {
+            if (kind === 0 /* FIELD */  || kind === 1 /* ACCESSOR */ ) {
+                desc = {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                };
+            } else if (kind === 3 /* GETTER */ ) {
+                desc = {
+                    get: decInfo[3]
+                };
+            } else if (kind === 4 /* SETTER */ ) {
+                desc = {
+                    set: decInfo[3]
+                };
+            } else {
+                desc = {
+                    value: decInfo[3]
+                };
+            }
+        } else if (kind !== 0 /* FIELD */ ) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+        if (kind === 1 /* ACCESSOR */ ) {
+            value = {
+                get: desc.get,
+                set: desc.set
+            };
+        } else if (kind === 2 /* METHOD */ ) {
+            value = desc.value;
+        } else if (kind === 3 /* GETTER */ ) {
+            value = desc.get;
+        } else if (kind === 4 /* SETTER */ ) {
+            value = desc.set;
+        }
+        var newValue, get, set;
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+                if (kind === 0 /* FIELD */ ) {
+                    init = newValue;
+                } else if (kind === 1 /* ACCESSOR */ ) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (kind === 0 /* FIELD */ ) {
+                        newInit = newValue;
+                    } else if (kind === 1 /* ACCESSOR */ ) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else {
+                        value = newValue;
+                    }
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [
+                                init,
+                                newInit
+                            ];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+        if (kind === 0 /* FIELD */  || kind === 1 /* ACCESSOR */ ) {
+            if (init === void 0) {
+                // If the initializer was void 0, sub in a dummy initializer
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (kind !== 0 /* FIELD */ ) {
+            if (kind === 1 /* ACCESSOR */ ) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2 /* METHOD */ ) {
+                desc.value = value;
+            } else if (kind === 3 /* GETTER */ ) {
+                desc.get = value;
+            } else if (kind === 4 /* SETTER */ ) {
+                desc.set = value;
+            }
+            if (isPrivate) {
+                if (kind === 1 /* ACCESSOR */ ) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2 /* METHOD */ ) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            // skip computed property names
+            if (!Array.isArray(decInfo)) continue;
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+            var isStatic = kind >= 5; /* STATIC */ 
+            var base;
+            var initializers;
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5 /* STATIC */ ;
+                // initialize staticInitializers when we see a non-field static member
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                // initialize protoInitializers when we see a non-field member
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+            if (kind !== 0 /* FIELD */  && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                var existingKind = existingNonFields.get(name) || 0;
+                if (existingKind === true || existingKind === 3 /* GETTER */  && kind !== 4 || existingKind === 4 /* SETTER */  && kind !== 3) {
+                    throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                } else if (!existingKind && kind > 2 /* METHOD */ ) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+                return instance;
+            });
+        }
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, /* CLASS */ nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
+                }
+            ];
+        }
+    // The transformer will not emit assignment when there are no class decorators,
+    // so we don't have to return an empty array here.
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    /**
+    Basic usage:
+
+    applyDecs(
+      Class,
+      [
+        // member decorators
+        [
+          dec,                // dec or array of decs
+          0,                  // kind of value being decorated
+          'prop',             // name of public prop on class containing the value being decorated,
+          '#p',               // the name of the private property (if is private, void 0 otherwise),
+        ]
+      ],
+      [
+        // class decorators
+        dec1, dec2
+      ]
+    )
+    ```
+
+    Fully transpiled example:
+
+    ```js
+    @dec
+    class Class {
+      @dec
+      a = 123;
+
+      @dec
+      #a = 123;
+
+      @dec
+      @dec2
+      accessor b = 123;
+
+      @dec
+      accessor #b = 123;
+
+      @dec
+      c() { console.log('c'); }
+
+      @dec
+      #c() { console.log('privC'); }
+
+      @dec
+      get d() { console.log('d'); }
+
+      @dec
+      get #d() { console.log('privD'); }
+
+      @dec
+      set e(v) { console.log('e'); }
+
+      @dec
+      set #e(v) { console.log('privE'); }
+    }
+
+
+    // becomes
+    let initializeInstance;
+    let initializeClass;
+
+    let initA;
+    let initPrivA;
+
+    let initB;
+    let initPrivB, getPrivB, setPrivB;
+
+    let privC;
+    let privD;
+    let privE;
+
+    let Class;
+    class _Class {
+      static {
+        let ret = applyDecs(
+          this,
+          [
+            [dec, 0, 'a'],
+            [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],
+            [[dec, dec2], 1, 'b'],
+            [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],
+            [dec, 2, 'c'],
+            [dec, 2, 'c', () => console.log('privC')],
+            [dec, 3, 'd'],
+            [dec, 3, 'd', () => console.log('privD')],
+            [dec, 4, 'e'],
+            [dec, 4, 'e', () => console.log('privE')],
+          ],
+          [
+            dec
+          ]
+        )
+
+        initA = ret[0];
+
+        initPrivA = ret[1];
+
+        initB = ret[2];
+
+        initPrivB = ret[3];
+        getPrivB = ret[4];
+        setPrivB = ret[5];
+
+        privC = ret[6];
+
+        privD = ret[7];
+
+        privE = ret[8];
+
+        initializeInstance = ret[9];
+
+        Class = ret[10]
+
+        initializeClass = ret[11];
+      }
+
+      a = (initializeInstance(this), initA(this, 123));
+
+      #a = initPrivA(this, 123);
+
+      #bData = initB(this, 123);
+      get b() { return this.#bData }
+      set b(v) { this.#bData = v }
+
+      #privBData = initPrivB(this, 123);
+      get #b() { return getPrivB(this); }
+      set #b(v) { setPrivB(this, v); }
+
+      c() { console.log('c'); }
+
+      #c(...args) { return privC(this, ...args) }
+
+      get d() { console.log('d'); }
+
+      get #d() { return privD(this); }
+
+      set e(v) { console.log('e'); }
+
+      set #e(v) { privE(this, v); }
+    }
+
+    initializeClass(Class);
+   */ _apply_decs_2203_r = function(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            // Lazily apply class decorations so that member init locals can be properly bound.
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+    return _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass);
+}
+
+export { _apply_decs_2203_r as _ };
+//# sourceMappingURL=cc-BEf4wTUm.js.map