@soda-gql/core 0.9.0 → 0.10.0

package/README.md

@@ -251,6 +251,73 @@ $var.getVariablePath(varRef, (p) => p.profile.name);
 // Returns: ["$user", "name"] (variable name + path after variable reference point)
 ```
 
+## Adapter
+
+Adapters customize the behavior of your GraphQL system with helpers, metadata configuration, and document transformation.
+
+### Basic Usage
+
+```typescript
+import { defineAdapter } from "@soda-gql/core/adapter";
+
+const adapter = defineAdapter({
+  helpers: {
+    auth: {
+      requiresLogin: () => ({ requiresAuth: true }),
+    },
+  },
+  metadata: {
+    aggregateFragmentMetadata: (fragments) => ({
+      count: fragments.length,
+    }),
+    schemaLevel: { apiVersion: "v2" },
+  },
+  transformDocument: ({ document, operationType }) => {
+    // Schema-wide document transformation
+    return document;
+  },
+});
+```
+
+### Document Transform
+
+Operations can also define their own transform with typed metadata:
+
+```typescript
+gql.default(({ query, $var }) =>
+  query.operation({
+    name: "GetUser",
+    metadata: () => ({ cacheHint: 300 }),
+    transformDocument: ({ document, metadata }) => {
+      // metadata is typed as { cacheHint: number }
+      return document;
+    },
+    fields: ({ f, $ }) => ({ ... }),
+  }),
+);
+```
+
+**Best Practice:** Define transform logic in helpers for reusability:
+
+```typescript
+const adapter = defineAdapter({
+  helpers: {
+    transform: {
+      addCache: (ttl: number) => ({ document }) => {
+        // Transform logic here
+        return document;
+      },
+    },
+  },
+});
+
+// Use helper in operation
+query.operation({
+  transformDocument: transform.addCache(300),
+  ...
+});
+```
+
 ## Runtime Exports
 
 The `/runtime` subpath provides utilities for operation registration and retrieval:

package/dist/adapter.cjs

@@ -1,11 +1,11 @@
-const require_schema = require('./schema-D2MW4DOF.cjs');
+const require_schema_builder = require('./schema-builder-D2ay11cE.cjs');
 
 //#region packages/core/src/adapter/define-adapter.ts
 /**
-* Helper function for defining a unified adapter with helpers and metadata.
-* Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+* Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+* Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
 *
-* @example
+* @example Basic adapter with helpers and metadata
 * ```typescript
 * import { defineAdapter } from "@soda-gql/core/adapter";
 * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -26,10 +26,57 @@ const require_schema = require('./schema-D2MW4DOF.cjs');
 *   },
 * });
 * ```
+*
+* @example Adapter with document transformation
+* ```typescript
+* import { defineAdapter } from "@soda-gql/core/adapter";
+* import { Kind, visit } from "graphql";
+*
+* export const adapter = defineAdapter({
+*   transformDocument: ({ document, operationType }) => {
+*     // Add @auth directive to all queries
+*     if (operationType === "query") {
+*       return visit(document, {
+*         OperationDefinition: (node) => ({
+*           ...node,
+*           directives: [
+*             ...(node.directives ?? []),
+*             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+*           ],
+*         }),
+*       });
+*     }
+*     return document;
+*   },
+* });
+* ```
+*
+* @example Using helpers for operation-level transform functions (recommended)
+* ```typescript
+* // Define transform functions as helpers for reusability
+* const adapter = defineAdapter({
+*   helpers: {
+*     transform: {
+*       addCacheDirective: (ttl: number) => ({ document }) => {
+*         return visit(document, { ... });
+*       },
+*     },
+*   },
+* });
+*
+* // Use helper in operation - clean and declarative
+* gql(({ query, transform }) =>
+*   query.operation({
+*     name: "GetUser",
+*     transformDocument: transform.addCacheDirective(300),
+*     fields: ({ f }) => ({ ... }),
+*   }),
+* );
+* ```
 */
 const defineAdapter = (adapter) => adapter;
 
 //#endregion
 exports.defineAdapter = defineAdapter;
-exports.defineScalar = require_schema.defineScalar;
+exports.defineScalar = require_schema_builder.defineScalar;
 //# sourceMappingURL=adapter.cjs.map

package/dist/adapter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.cjs","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers and metadata.\n * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.\n *\n * @example\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,iBAMX,YACoF"}
+{"version":3,"file":"adapter.cjs","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers, metadata, and document transformation.\n * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.\n *\n * @example Basic adapter with helpers and metadata\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n *\n * @example Adapter with document transformation\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import { Kind, visit } from \"graphql\";\n *\n * export const adapter = defineAdapter({\n *   transformDocument: ({ document, operationType }) => {\n *     // Add @auth directive to all queries\n *     if (operationType === \"query\") {\n *       return visit(document, {\n *         OperationDefinition: (node) => ({\n *           ...node,\n *           directives: [\n *             ...(node.directives ?? []),\n *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: \"auth\" } },\n *           ],\n *         }),\n *       });\n *     }\n *     return document;\n *   },\n * });\n * ```\n *\n * @example Using helpers for operation-level transform functions (recommended)\n * ```typescript\n * // Define transform functions as helpers for reusability\n * const adapter = defineAdapter({\n *   helpers: {\n *     transform: {\n *       addCacheDirective: (ttl: number) => ({ document }) => {\n *         return visit(document, { ... });\n *       },\n *     },\n *   },\n * });\n *\n * // Use helper in operation - clean and declarative\n * gql(({ query, transform }) =>\n *   query.operation({\n *     name: \"GetUser\",\n *     transformDocument: transform.addCacheDirective(300),\n *     fields: ({ f }) => ({ ... }),\n *   }),\n * );\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,MAAa,iBAMX,YACoF"}

package/dist/adapter.d.cts

@@ -1,13 +1,13 @@
-import { N as Adapter } from "./schema-CPTxQbTv.cjs";
-import { r as defineScalar } from "./schema-builder-BYJd50o2.cjs";
+import { t as Adapter } from "./index-DnLzk2bC.cjs";
+import { r as defineScalar } from "./schema-builder-CwRmtxHx.cjs";
 
 //#region packages/core/src/adapter/define-adapter.d.ts
 
 /**
- * Helper function for defining a unified adapter with helpers and metadata.
- * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+ * Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+ * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
  *
- * @example
+ * @example Basic adapter with helpers and metadata
  * ```typescript
  * import { defineAdapter } from "@soda-gql/core/adapter";
  * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -28,6 +28,53 @@ import { r as defineScalar } from "./schema-builder-BYJd50o2.cjs";
  *   },
  * });
  * ```
+ *
+ * @example Adapter with document transformation
+ * ```typescript
+ * import { defineAdapter } from "@soda-gql/core/adapter";
+ * import { Kind, visit } from "graphql";
+ *
+ * export const adapter = defineAdapter({
+ *   transformDocument: ({ document, operationType }) => {
+ *     // Add @auth directive to all queries
+ *     if (operationType === "query") {
+ *       return visit(document, {
+ *         OperationDefinition: (node) => ({
+ *           ...node,
+ *           directives: [
+ *             ...(node.directives ?? []),
+ *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+ *           ],
+ *         }),
+ *       });
+ *     }
+ *     return document;
+ *   },
+ * });
+ * ```
+ *
+ * @example Using helpers for operation-level transform functions (recommended)
+ * ```typescript
+ * // Define transform functions as helpers for reusability
+ * const adapter = defineAdapter({
+ *   helpers: {
+ *     transform: {
+ *       addCacheDirective: (ttl: number) => ({ document }) => {
+ *         return visit(document, { ... });
+ *       },
+ *     },
+ *   },
+ * });
+ *
+ * // Use helper in operation - clean and declarative
+ * gql(({ query, transform }) =>
+ *   query.operation({
+ *     name: "GetUser",
+ *     transformDocument: transform.addCacheDirective(300),
+ *     fields: ({ f }) => ({ ... }),
+ *   }),
+ * );
+ * ```
  */
 declare const defineAdapter: <THelpers extends object = object, TFragmentMetadata = unknown, TAggregatedFragmentMetadata = unknown, TSchemaLevel = unknown>(adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>) => Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
 //#endregion

package/dist/adapter.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.cts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}
+{"version":3,"file":"adapter.d.cts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}

package/dist/adapter.d.ts

@@ -1,13 +1,13 @@
-import { N as Adapter } from "./schema-2qqtKss4.js";
-import { r as defineScalar } from "./schema-builder-Dhss2O1I.js";
+import { t as Adapter } from "./index-CnQ5XVCf.js";
+import { r as defineScalar } from "./schema-builder-CJe30s_R.js";
 
 //#region packages/core/src/adapter/define-adapter.d.ts
 
 /**
- * Helper function for defining a unified adapter with helpers and metadata.
- * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+ * Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+ * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
  *
- * @example
+ * @example Basic adapter with helpers and metadata
  * ```typescript
  * import { defineAdapter } from "@soda-gql/core/adapter";
  * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -28,6 +28,53 @@ import { r as defineScalar } from "./schema-builder-Dhss2O1I.js";
  *   },
  * });
  * ```
+ *
+ * @example Adapter with document transformation
+ * ```typescript
+ * import { defineAdapter } from "@soda-gql/core/adapter";
+ * import { Kind, visit } from "graphql";
+ *
+ * export const adapter = defineAdapter({
+ *   transformDocument: ({ document, operationType }) => {
+ *     // Add @auth directive to all queries
+ *     if (operationType === "query") {
+ *       return visit(document, {
+ *         OperationDefinition: (node) => ({
+ *           ...node,
+ *           directives: [
+ *             ...(node.directives ?? []),
+ *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+ *           ],
+ *         }),
+ *       });
+ *     }
+ *     return document;
+ *   },
+ * });
+ * ```
+ *
+ * @example Using helpers for operation-level transform functions (recommended)
+ * ```typescript
+ * // Define transform functions as helpers for reusability
+ * const adapter = defineAdapter({
+ *   helpers: {
+ *     transform: {
+ *       addCacheDirective: (ttl: number) => ({ document }) => {
+ *         return visit(document, { ... });
+ *       },
+ *     },
+ *   },
+ * });
+ *
+ * // Use helper in operation - clean and declarative
+ * gql(({ query, transform }) =>
+ *   query.operation({
+ *     name: "GetUser",
+ *     transformDocument: transform.addCacheDirective(300),
+ *     fields: ({ f }) => ({ ... }),
+ *   }),
+ * );
+ * ```
  */
 declare const defineAdapter: <THelpers extends object = object, TFragmentMetadata = unknown, TAggregatedFragmentMetadata = unknown, TSchemaLevel = unknown>(adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>) => Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
 //#endregion

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}
+{"version":3,"file":"adapter.d.ts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}

package/dist/adapter.js

@@ -1,11 +1,11 @@
-import { r as defineScalar } from "./schema-BiYcVVvm.js";
+import { r as defineScalar } from "./schema-builder-C9Qj5zQg.js";
 
 //#region packages/core/src/adapter/define-adapter.ts
 /**
-* Helper function for defining a unified adapter with helpers and metadata.
-* Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+* Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+* Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
 *
-* @example
+* @example Basic adapter with helpers and metadata
 * ```typescript
 * import { defineAdapter } from "@soda-gql/core/adapter";
 * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -26,6 +26,53 @@ import { r as defineScalar } from "./schema-BiYcVVvm.js";
 *   },
 * });
 * ```
+*
+* @example Adapter with document transformation
+* ```typescript
+* import { defineAdapter } from "@soda-gql/core/adapter";
+* import { Kind, visit } from "graphql";
+*
+* export const adapter = defineAdapter({
+*   transformDocument: ({ document, operationType }) => {
+*     // Add @auth directive to all queries
+*     if (operationType === "query") {
+*       return visit(document, {
+*         OperationDefinition: (node) => ({
+*           ...node,
+*           directives: [
+*             ...(node.directives ?? []),
+*             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+*           ],
+*         }),
+*       });
+*     }
+*     return document;
+*   },
+* });
+* ```
+*
+* @example Using helpers for operation-level transform functions (recommended)
+* ```typescript
+* // Define transform functions as helpers for reusability
+* const adapter = defineAdapter({
+*   helpers: {
+*     transform: {
+*       addCacheDirective: (ttl: number) => ({ document }) => {
+*         return visit(document, { ... });
+*       },
+*     },
+*   },
+* });
+*
+* // Use helper in operation - clean and declarative
+* gql(({ query, transform }) =>
+*   query.operation({
+*     name: "GetUser",
+*     transformDocument: transform.addCacheDirective(300),
+*     fields: ({ f }) => ({ ... }),
+*   }),
+* );
+* ```
 */
 const defineAdapter = (adapter) => adapter;
 

package/dist/adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.js","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers and metadata.\n * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.\n *\n * @example\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,iBAMX,YACoF"}
+{"version":3,"file":"adapter.js","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers, metadata, and document transformation.\n * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.\n *\n * @example Basic adapter with helpers and metadata\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n *\n * @example Adapter with document transformation\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import { Kind, visit } from \"graphql\";\n *\n * export const adapter = defineAdapter({\n *   transformDocument: ({ document, operationType }) => {\n *     // Add @auth directive to all queries\n *     if (operationType === \"query\") {\n *       return visit(document, {\n *         OperationDefinition: (node) => ({\n *           ...node,\n *           directives: [\n *             ...(node.directives ?? []),\n *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: \"auth\" } },\n *           ],\n *         }),\n *       });\n *     }\n *     return document;\n *   },\n * });\n * ```\n *\n * @example Using helpers for operation-level transform functions (recommended)\n * ```typescript\n * // Define transform functions as helpers for reusability\n * const adapter = defineAdapter({\n *   helpers: {\n *     transform: {\n *       addCacheDirective: (ttl: number) => ({ document }) => {\n *         return visit(document, { ... });\n *       },\n *     },\n *   },\n * });\n *\n * // Use helper in operation - clean and declarative\n * gql(({ query, transform }) =>\n *   query.operation({\n *     name: \"GetUser\",\n *     transformDocument: transform.addCacheDirective(300),\n *     fields: ({ f }) => ({ ... }),\n *   }),\n * );\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,MAAa,iBAMX,YACoF"}