@mostajs/orm-adapter 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+All notable changes to `@mostajs/orm-adapter` will be documented in this file.
+
+## [0.2.0] — 2026-04-12
+
+### Added
+
+- **PrismaAdapter** : converts `.prisma` files to `EntitySchema[]`
+  - All scalar types : String, Int, BigInt, Float, Decimal, Boolean, DateTime, Json, Bytes
+  - Modifiers : `?` (optional), `[]` (array)
+  - Field attributes : `@id`, `@unique`, `@default`, `@map`, `@updatedAt`, `@db.VarChar(n)`
+  - Model attributes : `@@id`, `@@unique`, `@@index`, `@@map`, `@@schema`, `@@fulltext`
+  - Enums (as `FieldDef.enum`)
+  - Relations : 1-1, 1-N, many-to-one, implicit M-N (synthesized `_ATo B` junction)
+  - Self-relations (named via `@relation("Name")`)
+  - Referential actions : Cascade, SetNull, Restrict, NoAction, SetDefault (warn → set-null)
+  - `@default` sentinels : AUTOINCREMENT, NOW, UUID_V4/V7, CUID/CUID2, NANOID, ULID, OBJECT_ID
+  - Auto-detection of `createdAt` + `updatedAt` convention → `timestamps: true`
+- **Utils** : `prisma-ast-helpers`, `prisma-type-mapper`, `prisma-default-mapper`
+- **DefaultSentinel** constants exported for downstream ORM interpretation
+- 55 new unit tests (all passing) on 4 fixtures (blog, scalars, m2m-implicit, self-relation)
+
+### Changed
+
+- `createDefaultRegistry()` now pre-registers PrismaAdapter alongside NativeAdapter
+
+### Warnings emitted (new)
+
+- `LOSSY_CONVERSION` on BigInt, Decimal, Bytes
+- `UNSUPPORTED_FEATURE` on `Unsupported("...")`, `@@ignore`, `onDelete: SetDefault`
+- `PREVIEW_FEATURE` on `view`, composite `type`, `@@fulltext`, `@@schema`
+- `UNKNOWN_EXTENSION` on unrecognized `@default(fn())`
+
+## [0.1.0] — 2026-04-12
+
+### Added
+
+- Initial release
+- **Core abstractions** : `IAdapter`, `AbstractAdapter`, `AdapterRegistry`
+- **NativeAdapter** : passthrough for @mostajs/orm EntitySchema with structural validation
+- Error types : `AdapterError`, `NoAdapterFoundError`, `InvalidSchemaError`, `StrictWarningError`
+- Warning system with 8 standard codes (`UNSUPPORTED_FEATURE`, `LOSSY_CONVERSION`, etc.)
+- Strict mode (warnings as exceptions)
+- Helpers : case conversion (snake/pascal/camel), schema validation
+- `createDefaultRegistry()` factory
+- 31 unit tests (all passing)
+- AGPL-3.0-or-later license + commercial option
+
+### Planned for v0.2.0
+
+- PrismaAdapter (MVP covering scalars, 1-1, 1-N, M-N, enums, native types)
+
+### Planned for v0.3.0
+
+- JsonSchemaAdapter (Draft 2020-12 + Draft-07 compat)
+
+### Planned for v0.4.0
+
+- OpenApiAdapter (3.1 with 3.0 normalization)

package/LICENSE

@@ -0,0 +1,29 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+Copyright (c) 2026 Dr Hamid MADANI <drmdh@msn.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+COMMERCIAL LICENSE
+
+For organizations that cannot comply with the AGPL open-source requirements,
+a commercial license is available. Contact: drmdh@msn.com
+
+The commercial license allows you to:
+- Use the software in proprietary/closed-source projects
+- Modify without publishing your source code
+- Get priority support and SLA
+
+Contact: Dr Hamid MADANI <drmdh@msn.com>

package/README.md

@@ -0,0 +1,182 @@
+# @mostajs/orm-adapter
+
+> Third-party schema adapters for [@mostajs/orm](https://github.com/apolocine/mosta-orm).
+> Convert Prisma, JSON Schema, OpenAPI, and more to `EntitySchema[]`.
+
+[![npm version](https://img.shields.io/npm/v/@mostajs/orm-adapter.svg)](https://www.npmjs.com/package/@mostajs/orm-adapter)
+[![License: AGPL-3.0-or-later](https://img.shields.io/badge/License-AGPL%203.0-blue.svg)](LICENSE)
+
+## Why
+
+@mostajs/orm supports **13 databases** with a unified `EntitySchema` format. This package bridges that format with the rest of the ecosystem, letting you reuse schemas you already have:
+
+- **Prisma** `.prisma` files → EntitySchema[] (planned)
+- **JSON Schema** Draft 2020-12 → EntitySchema[] (planned)
+- **OpenAPI 3.1** `components/schemas` → EntitySchema[] (planned)
+- **Native** EntitySchema → EntitySchema[] (passthrough, **v0.1.0**)
+
+## Install
+
+```bash
+npm install @mostajs/orm-adapter @mostajs/orm
+```
+
+## Quick start
+
+### Native passthrough (validation layer)
+
+```ts
+import { NativeAdapter } from '@mostajs/orm-adapter';
+import type { EntitySchema } from '@mostajs/orm';
+
+const UserSchema: EntitySchema = {
+  name: 'User',
+  collection: 'users',
+  fields: {
+    email: { type: 'string', required: true, unique: true },
+  },
+  relations: {},
+  indexes: [{ fields: { email: 'asc' }, unique: true }],
+  timestamps: true,
+};
+
+const adapter = new NativeAdapter();
+const entities = await adapter.toEntitySchema(UserSchema);
+// -> EntitySchema[]
+```
+
+### Auto-detection via Registry
+
+```ts
+import { createDefaultRegistry } from '@mostajs/orm-adapter';
+
+const registry = createDefaultRegistry();
+const entities = await registry.fromAny(unknownInput);
+// Auto-detects format (native / prisma / jsonschema / openapi)
+```
+
+### Strict mode — fail fast on invalid schema
+
+```ts
+try {
+  await adapter.toEntitySchema(maybeInvalid, { strict: true });
+} catch (e) {
+  if (e instanceof InvalidSchemaError) console.error(e.details);
+}
+```
+
+### Collect warnings for logging
+
+```ts
+await adapter.toEntitySchema(userSchema, {
+  onWarning: (w) => logger.warn(`[${w.code}] ${w.message}`, {
+    entity: w.entity,
+    field: w.field,
+  }),
+});
+```
+
+## API
+
+### `IAdapter` interface
+
+```ts
+interface IAdapter {
+  readonly name: string;
+  readonly vendor: string;
+  readonly version: string;
+  canParse(input: string | object): boolean;
+  toEntitySchema(input: string | object, opts?: AdapterOptions): Promise<EntitySchema[]>;
+  fromEntitySchema?(entities: EntitySchema[], opts?: AdapterOptions): Promise<string | object>;
+}
+```
+
+### `AdapterOptions`
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `strict` | `boolean` | Warnings become exceptions (fail-fast) |
+| `onWarning` | `(w: AdapterWarning) => void` | Callback for each warning |
+| `extensions` | `Record<string, unknown>` | Custom values for x-mostajs-* |
+| `relationStrategy` | `'explicit' \| 'auto' \| 'none'` | Relation detection mode |
+| `unknownTypesFallback` | `'json' \| 'error' \| 'string'` | Fallback for unmappable types |
+
+### Warning codes
+
+- `UNSUPPORTED_FEATURE` — source has a feature the target cannot express
+- `LOSSY_CONVERSION` — precision or constraint lost during mapping
+- `MISSING_METADATA` — expected metadata absent
+- `AMBIGUOUS_MAPPING` — multiple valid interpretations
+- `PREVIEW_FEATURE` — experimental/preview feature used
+- `FALLBACK_APPLIED` — default strategy used
+- `CYCLIC_REFERENCE` — self-referencing schema detected
+- `UNKNOWN_EXTENSION` — unrecognized x-* extension
+
+## Building your own adapter
+
+```ts
+import { AbstractAdapter, type AdapterOptions, WarningCode } from '@mostajs/orm-adapter';
+import type { EntitySchema } from '@mostajs/orm';
+
+export class MyCustomAdapter extends AbstractAdapter {
+  readonly name = 'my-format';
+  readonly vendor = 'my-org';
+  readonly version = '0.1.0';
+
+  canParse(input: string | object): boolean {
+    // Fast, non-destructive detection
+    return typeof input === 'string' && input.includes('@my-format');
+  }
+
+  async toEntitySchema(input: string | object, opts?: AdapterOptions): Promise<EntitySchema[]> {
+    // 1. Parse your source format
+    // 2. Map to EntitySchema[]
+    // 3. Emit warnings for lossy conversions
+    this.warn(opts, {
+      code: WarningCode.LOSSY_CONVERSION,
+      message: 'Some feature lost during mapping',
+      entity: 'Foo',
+    });
+    return [/* ... */];
+  }
+}
+```
+
+## Roadmap
+
+- **v0.1.0** — NativeAdapter + core (AbstractAdapter, Registry) ✅
+- **v0.2.0** — PrismaAdapter (scalars, relations, enums, implicit M-N) ✅
+- **v0.3.0** — JsonSchemaAdapter (Draft 2020-12 + Draft-07)
+- **v0.4.0** — OpenApiAdapter (3.1 with 3.0 normalization)
+- **v1.0.0** — Production-ready, all 4 adapters with reverse conversion
+
+## PrismaAdapter example
+
+```ts
+import { PrismaAdapter, DefaultSentinel } from '@mostajs/orm-adapter';
+import { readFileSync } from 'fs';
+
+const source = readFileSync('./schema.prisma', 'utf8');
+const adapter = new PrismaAdapter();
+const entities = await adapter.toEntitySchema(source, {
+  onWarning: (w) => console.warn(`[${w.code}] ${w.message}`),
+});
+
+// entities: EntitySchema[] — feed directly to @mostajs/orm
+// Supports 13 databases (Postgres, Oracle, DB2, MongoDB, etc.)
+// where Prisma only supports 7.
+```
+
+## License
+
+**AGPL-3.0-or-later** + commercial license available.
+
+For commercial use in closed-source projects, contact: drmdh@msn.com
+
+## Author
+
+Dr Hamid MADANI <drmdh@msn.com>
+
+---
+
+Part of the [@mostajs ecosystem](https://github.com/apolocine) — 13 databases, 11 transports, one unified backend.

package/dist/adapters/native.adapter.d.ts

@@ -0,0 +1,36 @@
+import type { EntitySchema } from '@mostajs/orm';
+import { AbstractAdapter } from '../core/abstract.adapter.js';
+import type { AdapterOptions } from '../core/types.js';
+/**
+ * NativeAdapter — accepts EntitySchema objects directly (passthrough).
+ *
+ * Use cases:
+ *  - baseline to validate the IAdapter contract
+ *  - allows mixing native and third-party schemas in one Registry
+ *  - adds structural validation before handing off to the ORM
+ */
+export declare class NativeAdapter extends AbstractAdapter {
+    readonly name = "native";
+    readonly vendor = "@mostajs/orm";
+    readonly version = "0.1.0";
+    /**
+     * Detects an EntitySchema by structural shape (duck typing).
+     * Accepts both single schema and array of schemas.
+     */
+    canParse(input: string | object): boolean;
+    /**
+     * Passthrough : validates each schema, emits warnings if invalid,
+     * throws InvalidSchemaError in strict mode.
+     */
+    toEntitySchema(input: EntitySchema | EntitySchema[] | object, opts?: AdapterOptions): Promise<EntitySchema[]>;
+    /**
+     * Reverse : native format IS the EntitySchema — identity function.
+     */
+    fromEntitySchema(entities: EntitySchema[]): Promise<EntitySchema[]>;
+    /**
+     * Duck-type check : does the object look like an EntitySchema?
+     * Checks for required structural fields without deep validation.
+     */
+    private isEntitySchemaShape;
+}
+//# sourceMappingURL=native.adapter.d.ts.map

package/dist/adapters/native.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/native.adapter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIvD;;;;;;;GAOG;AACH,qBAAa,aAAc,SAAQ,eAAe;IAChD,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,MAAM,kBAAkB;IACjC,QAAQ,CAAC,OAAO,WAAW;IAE3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAQzC;;;OAGG;IACG,cAAc,CAClB,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE,GAAG,MAAM,EAC7C,IAAI,CAAC,EAAE,cAAc,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC;IAyB1B;;OAEG;IACG,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAQzE;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAc5B"}

package/dist/adapters/native.adapter.js

@@ -0,0 +1,83 @@
+// @mostajs/orm-adapter — NativeAdapter
+// Passthrough adapter for the native @mostajs/orm EntitySchema format.
+// Useful as baseline, detection fallback, and validation layer.
+// Author: Dr Hamid MADANI drmdh@msn.com
+// License: AGPL-3.0-or-later
+import { AbstractAdapter } from '../core/abstract.adapter.js';
+import { WarningCode } from '../core/types.js';
+import { InvalidSchemaError } from '../core/errors.js';
+/**
+ * NativeAdapter — accepts EntitySchema objects directly (passthrough).
+ *
+ * Use cases:
+ *  - baseline to validate the IAdapter contract
+ *  - allows mixing native and third-party schemas in one Registry
+ *  - adds structural validation before handing off to the ORM
+ */
+export class NativeAdapter extends AbstractAdapter {
+    name = 'native';
+    vendor = '@mostajs/orm';
+    version = '0.1.0';
+    /**
+     * Detects an EntitySchema by structural shape (duck typing).
+     * Accepts both single schema and array of schemas.
+     */
+    canParse(input) {
+        if (typeof input === 'string')
+            return false;
+        if (Array.isArray(input)) {
+            return input.length === 0 || this.isEntitySchemaShape(input[0]);
+        }
+        return this.isEntitySchemaShape(input);
+    }
+    /**
+     * Passthrough : validates each schema, emits warnings if invalid,
+     * throws InvalidSchemaError in strict mode.
+     */
+    async toEntitySchema(input, opts) {
+        const array = Array.isArray(input) ? input : [input];
+        for (const schema of array) {
+            const errors = this.validateEntitySchema(schema);
+            if (errors.length > 0) {
+                if (opts?.strict) {
+                    throw new InvalidSchemaError(`Invalid EntitySchema: ${errors.join('; ')}`, { schema, errors });
+                }
+                for (const err of errors) {
+                    this.warn(opts, {
+                        code: WarningCode.MISSING_METADATA,
+                        message: err,
+                        entity: schema.name,
+                    });
+                }
+            }
+        }
+        return array;
+    }
+    /**
+     * Reverse : native format IS the EntitySchema — identity function.
+     */
+    async fromEntitySchema(entities) {
+        return entities;
+    }
+    // ============================================================
+    // Private helpers
+    // ============================================================
+    /**
+     * Duck-type check : does the object look like an EntitySchema?
+     * Checks for required structural fields without deep validation.
+     */
+    isEntitySchemaShape(obj) {
+        if (!obj || typeof obj !== 'object')
+            return false;
+        const o = obj;
+        return (typeof o.name === 'string' &&
+            typeof o.collection === 'string' &&
+            typeof o.fields === 'object' &&
+            o.fields !== null &&
+            typeof o.relations === 'object' &&
+            o.relations !== null &&
+            Array.isArray(o.indexes) &&
+            typeof o.timestamps === 'boolean');
+    }
+}
+//# sourceMappingURL=native.adapter.js.map

package/dist/adapters/native.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.adapter.js","sourceRoot":"","sources":["../../src/adapters/native.adapter.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,uEAAuE;AACvE,gEAAgE;AAChE,wCAAwC;AACxC,6BAA6B;AAG7B,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,OAAO,aAAc,SAAQ,eAAe;IACvC,IAAI,GAAG,QAAQ,CAAC;IAChB,MAAM,GAAG,cAAc,CAAC;IACxB,OAAO,GAAG,OAAO,CAAC;IAE3B;;;OAGG;IACH,QAAQ,CAAC,KAAsB;QAC7B,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAC5C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc,CAClB,KAA6C,EAC7C,IAAqB;QAErB,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAqB,CAAC,CAAC;QAErE,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;YACjD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtB,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;oBACjB,MAAM,IAAI,kBAAkB,CAC1B,yBAAyB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAC5C,EAAE,MAAM,EAAE,MAAM,EAAE,CACnB,CAAC;gBACJ,CAAC;gBACD,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;oBACzB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;wBACd,IAAI,EAAE,WAAW,CAAC,gBAAgB;wBAClC,OAAO,EAAE,GAAG;wBACZ,MAAM,EAAE,MAAM,CAAC,IAAI;qBACpB,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,KAAuB,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,gBAAgB,CAAC,QAAwB;QAC7C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,+DAA+D;IAC/D,kBAAkB;IAClB,+DAA+D;IAE/D;;;OAGG;IACK,mBAAmB,CAAC,GAAY;QACtC,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAClD,MAAM,CAAC,GAAG,GAA8B,CAAC;QACzC,OAAO,CACL,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ;YAC1B,OAAO,CAAC,CAAC,UAAU,KAAK,QAAQ;YAChC,OAAO,CAAC,CAAC,MAAM,KAAK,QAAQ;YAC5B,CAAC,CAAC,MAAM,KAAK,IAAI;YACjB,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ;YAC/B,CAAC,CAAC,SAAS,KAAK,IAAI;YACpB,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;YACxB,OAAO,CAAC,CAAC,UAAU,KAAK,SAAS,CAClC,CAAC;IACJ,CAAC;CACF"}

package/dist/adapters/prisma.adapter.d.ts

@@ -0,0 +1,48 @@
+import type { EntitySchema } from '@mostajs/orm';
+import { AbstractAdapter } from '../core/abstract.adapter.js';
+import { type AdapterOptions } from '../core/types.js';
+/**
+ * PrismaAdapter — converts .prisma files to EntitySchema[].
+ *
+ * Supports (MVP v0.2.0):
+ *  - All scalar types (String, Int, BigInt, Float, Decimal, Boolean, DateTime, Json, Bytes)
+ *  - Modifiers (?, [])
+ *  - @id, @unique, @default, @map, @updatedAt
+ *  - @@id, @@unique, @@index, @@map
+ *  - @db.VarChar(N), @db.Decimal(p,s) (metadata extraction)
+ *  - Enums (as FieldDef.enum)
+ *  - Relations 1-1, 1-N, M-N (implicit & explicit)
+ *  - Self-relations (named)
+ *  - onDelete actions (Cascade, SetNull, Restrict, NoAction, SetDefault)
+ *
+ * Not yet supported (v0.3+):
+ *  - Composite types (MongoDB embedded docs)
+ *  - Views (preview)
+ *  - Multi-schema
+ *  - @@fulltext, specialized @@index(type: Gin)
+ */
+export declare class PrismaAdapter extends AbstractAdapter {
+    readonly name = "prisma";
+    readonly vendor = "prisma.io";
+    readonly version = "0.2.0";
+    canParse(input: string | object): boolean;
+    toEntitySchema(input: string | object, opts?: AdapterOptions): Promise<EntitySchema[]>;
+    private modelToEntity;
+    private resolveTableName;
+    private isRelationField;
+    private fieldToFieldDef;
+    private applyFieldAttributes;
+    private fieldToRelation;
+    private mapReferentialAction;
+    private applyBlockAttribute;
+    /**
+     * Prisma allows implicit M-N: `categories Category[]` on both sides with NO join
+     * table declared. The adapter detects these and upgrades one-to-many pairs to
+     * many-to-many, synthesizing `through` as `_${A}To${B}` (Prisma's convention).
+     */
+    private synthesizeImplicitM2M;
+    private hasTimestampsConvention;
+    private unquote;
+    private detectPreviewFeatures;
+}
+//# sourceMappingURL=prisma.adapter.d.ts.map

package/dist/adapters/prisma.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/prisma.adapter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAiE,MAAM,cAAc,CAAC;AAChH,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAe,KAAK,cAAc,EAAuB,MAAM,kBAAkB,CAAC;AAoBzF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,aAAc,SAAQ,eAAe;IAChD,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,MAAM,eAAe;IAC9B,QAAQ,CAAC,OAAO,WAAW;IAE3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAMnC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAmC5F,OAAO,CAAC,aAAa;IAyCrB,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,eAAe;IA4DvB,OAAO,CAAC,oBAAoB;IAuC5B,OAAO,CAAC,eAAe;IAsDvB,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,mBAAmB;IA0E3B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA2C7B,OAAO,CAAC,uBAAuB;IAK/B,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,qBAAqB;CAgB9B"}