@warp-drive/legacy 5.6.0-alpha.11

package/declarations/serializer/-private/transforms/transform.d.ts

@@ -0,0 +1,119 @@
+import EmberObject from '@ember/object';
+import type { LegacyAttributeField } from '@warp-drive/core/types/schema/fields';
+/**
+  The `Transform` class is used to serialize and deserialize model
+  attributes when they are saved or loaded from an
+  adapter. Subclassing `Transform` is useful for creating custom
+  attributes. All subclasses of `Transform` must implement a
+  `serialize` and a `deserialize` method.
+
+  Example
+
+  ```js [app/transforms/temperature.js]
+
+  // Converts centigrade in the JSON to fahrenheit in the app
+  export default class TemperatureTransform {
+    deserialize(serialized, options) {
+      return (serialized *  1.8) + 32;
+    }
+
+    serialize(deserialized, options) {
+      return (deserialized - 32) / 1.8;
+    }
+
+    static create() {
+      return new this();
+    }
+  }
+  ```
+
+  Usage
+
+  ```js [app/models/requirement.js]
+  import { Model, attr } from '@warp-drive/legacy/model';
+
+  export default class RequirementModel extends Model {
+    @attr('string') name;
+    @attr('temperature') temperature;
+  }
+  ```
+
+  The options passed into the `attr` function when the attribute is
+  declared on the model is also available in the transform.
+
+  ```js [app/models/post.js]
+  import { Model, attr } from '@warp-drive/legacy/model';
+
+  export default class PostModel extends Model {
+    @attr('string') title;
+    @attr('markdown', {
+      markdown: {
+        gfm: false,
+        sanitize: true
+      }
+    })
+    markdown;
+  }
+  ```
+
+  ```js [app/transforms/markdown.js]
+  export default class MarkdownTransform {
+    serialize(deserialized, options) {
+      return deserialized.raw;
+    }
+
+    deserialize(serialized, options) {
+      let markdownOptions = options.markdown || {};
+
+      return marked(serialized, markdownOptions);
+    }
+
+    static create() {
+      return new this();
+    }
+  }
+  ```
+
+  @class Transform
+  @public
+ */
+/**
+  When given a deserialized value from a record attribute this
+  method must return the serialized value.
+
+  Example
+
+  ```javascript
+  serialize(deserialized, options) {
+    return deserialized ? null : Number(deserialized);
+  }
+  ```
+
+  @public
+  @param deserialized The deserialized value
+  @param options hash of options passed to `attr`
+  @return The serialized value
+*/
+/**
+  When given a serialized value from a JSON object this method must
+  return the deserialized value for the record attribute.
+
+  Example
+
+  ```javascript
+  deserialize(serialized, options) {
+    return empty(serialized) ? null : Number(serialized);
+  }
+  ```
+
+  @public
+  @param serialized The serialized value
+  @param options hash of options passed to `attr`
+  @return The deserialized value
+*/
+export interface Transform {
+    serialize(value: unknown, options: LegacyAttributeField['options']): unknown;
+    deserialize(value: unknown, options: LegacyAttributeField['options']): unknown;
+}
+export declare const Transform: typeof EmberObject;
+//# sourceMappingURL=transform.d.ts.map

package/declarations/serializer/-private/transforms/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../../src/serializer/-private/transforms/transform.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH;;;;;;;;;;;;;;;;EAgBE;AACF;;;;;;;;;;;;;;;;EAgBE;AACF,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;IAC7E,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;CAChF;AACD,eAAO,MAAM,SAAS,oBAAc,CAAC"}

package/declarations/serializer/-private/utils.d.ts

@@ -0,0 +1,4 @@
+type Coercable = string | number | boolean | null | undefined | symbol;
+export declare function coerceId(id: Coercable): string | null;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/declarations/serializer/-private/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/serializer/-private/utils.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;AAEvE,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAUrD"}

package/declarations/serializer/json-api.d.ts

@@ -0,0 +1,496 @@
+/**
+ * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
+  <p>
+    ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+    If starting a new app or thinking of implementing a new adapter, consider writing a
+    <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
+  </p>
+  </blockquote>
+
+  In EmberData a Serializer is used to serialize and deserialize
+  records when they are transferred in and out of an external source.
+  This process involves normalizing property names, transforming
+  attribute values and serializing relationships.
+
+  `JSONAPISerializer` supports the http://jsonapi.org/ spec and is the
+  serializer recommended by Ember Data.
+
+  This serializer normalizes a JSON API payload that looks like:
+
+  ```js [app/models/player.js]
+  import Model, { attr, belongsTo } from '@ember-data/model';
+
+  export default class Player extends Model {
+    @attr('string') name;
+    @attr('string') skill;
+    @attr('number') gamesPlayed;
+    @belongsTo('club') club;
+  }
+  ```
+
+  ```js [app/models/club.js]
+  import Model, { attr, hasMany } from '@ember-data/model';
+
+  export default class Club extends Model {
+    @attr('string') name;
+    @attr('string') location;
+    @hasMany('player') players;
+  }
+  ```
+
+  ```js
+    {
+      "data": [
+        {
+          "attributes": {
+            "name": "Benfica",
+            "location": "Portugal"
+          },
+          "id": "1",
+          "relationships": {
+            "players": {
+              "data": [
+                {
+                  "id": "3",
+                  "type": "players"
+                }
+              ]
+            }
+          },
+          "type": "clubs"
+        }
+      ],
+      "included": [
+        {
+          "attributes": {
+            "name": "Eusebio Silva Ferreira",
+            "skill": "Rocket shot",
+            "games-played": 431
+          },
+          "id": "3",
+          "relationships": {
+            "club": {
+              "data": {
+                "id": "1",
+                "type": "clubs"
+              }
+            }
+          },
+          "type": "players"
+        }
+      ]
+    }
+  ```
+
+  to the format that the Ember Data store expects.
+
+  ### Customizing meta
+
+  Since a JSON API Document can have meta defined in multiple locations you can
+  use the specific serializer hooks if you need to customize the meta.
+
+  One scenario would be to camelCase the meta keys of your payload. The example
+  below shows how this could be done using `normalizeArrayResponse` and
+  `extractRelationship`.
+
+  ```js [app/serializers/application.js]
+  import JSONAPISerializer from '@ember-data/serializer/json-api';
+
+  export default class ApplicationSerializer extends JSONAPISerializer {
+    normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {
+      let normalizedDocument = super.normalizeArrayResponse(...arguments);
+
+      // Customize document meta
+      normalizedDocument.meta = camelCaseKeys(normalizedDocument.meta);
+
+      return normalizedDocument;
+    }
+
+    extractRelationship(relationshipHash) {
+      let normalizedRelationship = super.extractRelationship(...arguments);
+
+      // Customize relationship meta
+      normalizedRelationship.meta = camelCaseKeys(normalizedRelationship.meta);
+
+      return normalizedRelationship;
+    }
+  }
+  ```
+
+  @since 1.13.0
+  @class JSONAPISerializer
+  @public
+*/
+export const JSONAPISerializer: Readonly<Readonly<typeof import("../serializer.js").Serializer> & (new (owner?: import("@ember/-internals/owner").default) => import("../serializer.js").Serializer) & {
+    primaryKey: string;
+    mergedProperties: any;
+    applyTransforms(typeClass: Model, data: any): any;
+    normalizeResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, ...args: any[]): any;
+    normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string): any;
+    normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string): any;
+    _normalizeResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, isSingle: boolean): any;
+    normalize(modelClass: any, resourceHash: any): any;
+    extractId(modelClass: any, resourceHash: any): string;
+    extractAttributes(modelClass: any, resourceHash: any): any;
+    extractRelationship(relationshipModelName: any, relationshipHash: any): any;
+    extractPolymorphicRelationship(relationshipModelName: any, relationshipHash: any, relationshipOptions: any): any;
+    extractRelationships(modelClass: any, resourceHash: any): any;
+    modelNameFromPayloadKey(key: string): string;
+    normalizeRelationships(typeClass: any, hash: any): void;
+    normalizeUsingDeclaredMapping(modelClass: any, hash: any): void;
+    _getMappedKey(key: string, modelClass: any): string;
+    _canSerialize(key: string): boolean;
+    _mustSerialize(key: string): boolean;
+    shouldSerializeHasMany(snapshot: Snapshot, key: string, relationship: RelationshipSchema): boolean;
+    serialize(snapshot: Snapshot, options: any): any;
+    serializeIntoHash(hash: any, typeClass: Model, snapshot: Snapshot, options: any): void;
+    serializeAttribute(snapshot: Snapshot, json: any, key: string, attribute: any): void;
+    serializeBelongsTo(snapshot: Snapshot, json: any, relationship: any): void;
+    serializeHasMany(snapshot: Snapshot, json: any, relationship: any): void;
+    serializePolymorphicType(): void;
+    extractMeta(store: Store, modelClass: Model, payload: any): any;
+    extractErrors(store: Store, typeClass: Model, payload: any, id: (string | number)): any;
+    keyForAttribute(key: string, method: string): string;
+    keyForRelationship(key: string, typeClass: string, method: string): string;
+    keyForLink(key: string, kind: string): string;
+    transformFor(attributeType: string, skipAssertion: boolean): Transform;
+}> & (new (owner?: import("@ember/-internals/owner").default) => import("../serializer.js").Serializer) & {
+    /**
+      @param {Object} documentHash
+      @return {Object}
+      @private
+    */
+    _normalizeDocumentHelper(documentHash: any): any;
+    /**
+      @param {Object} relationshipDataHash
+      @return {Object}
+      @private
+    */
+    _normalizeRelationshipDataHelper(relationshipDataHash: any): any;
+    /**
+      @param {Object} resourceHash
+      @return {Object}
+      @private
+    */
+    _normalizeResourceHelper(resourceHash: any): any;
+    /**
+      Normalize some data and push it into the store.
+  
+      @public
+      @param {Store} store
+      @param {Object} payload
+    */
+    pushPayload(store: Store, payload: any): void;
+    /**
+      @param {Store} store
+      @param {Model} primaryModelClass
+      @param {Object} payload
+      @param {String|Number} id
+      @param {String} requestType
+      @param {Boolean} isSingle
+      @return {Object} JSON-API Document
+      @private
+    */
+    _normalizeResponse(store: Store, primaryModelClass: Model, payload: any, id: string | number, requestType: string, isSingle: boolean): any;
+    normalizeQueryRecordResponse(...args: any[]): any;
+    extractAttributes(modelClass: any, resourceHash: any): {};
+    /**
+       Returns a relationship formatted as a JSON-API "relationship object".
+  
+       http://jsonapi.org/format/#document-resource-object-relationships
+  
+      @public
+       @param {Object} relationshipHash
+       @return {Object}
+    */
+    extractRelationship(relationshipHash: any): any;
+    /**
+       Returns the resource's relationships formatted as a JSON-API "relationships object".
+  
+       http://jsonapi.org/format/#document-resource-object-relationships
+  
+      @public
+       @param {Object} modelClass
+       @param {Object} resourceHash
+       @return {Object}
+    */
+    extractRelationships(modelClass: any, resourceHash: any): any;
+    /**
+      @param {Model} modelClass
+      @param {Object} resourceHash
+      @return {String}
+      @private
+    */
+    _extractType(modelClass: Model, resourceHash: any): string;
+    /**
+      Dasherizes and singularizes the model name in the payload to match
+      the format Ember Data uses internally for the model name.
+  
+      For example the key `posts` would be converted to `post` and the
+      key `studentAssesments` would be converted to `student-assesment`.
+  
+      @public
+      @param {String} key
+      @return {String} the model's modelName
+    */
+    modelNameFromPayloadKey(key: string): string;
+    /**
+      Converts the model name to a pluralized version of the model name.
+  
+      For example `post` would be converted to `posts` and
+      `student-assesment` would be converted to `student-assesments`.
+  
+      @public
+      @param {String} modelName
+      @return {String}
+    */
+    payloadKeyFromModelName(modelName: string): string;
+    normalize(modelClass: any, resourceHash: any): {
+        data: {
+            id: any;
+            type: string;
+            attributes: {};
+            relationships: any;
+        };
+    };
+    /**
+      `keyForAttribute` can be used to define rules for how to convert an
+      attribute name in your model to a key in your JSON.
+      By default `JSONAPISerializer` follows the format used on the examples of
+      http://jsonapi.org/format and uses dashes as the word separator in the JSON
+      attribute keys.
+  
+      This behaviour can be easily customized by extending this method.
+  
+      Example
+  
+      ```js [app/serializers/application.js]
+      import JSONAPISerializer from '@ember-data/serializer/json-api';
+      import { dasherize } from '<app-name>/utils/string-utils';
+  
+      export default class ApplicationSerializer extends JSONAPISerializer {
+        keyForAttribute(attr, method) {
+          return dasherize(attr).toUpperCase();
+        }
+      }
+      ```
+  
+      @public
+      @param {String} key
+      @param {String} method
+      @return {String} normalized key
+    */
+    keyForAttribute(key: string, method: string): string;
+    /**
+     `keyForRelationship` can be used to define a custom key when
+     serializing and deserializing relationship properties.
+     By default `JSONAPISerializer` follows the format used on the examples of
+     http://jsonapi.org/format and uses dashes as word separators in
+     relationship properties.
+  
+     This behaviour can be easily customized by extending this method.
+  
+     Example
+  
+      ```js [app/serializers/post.js]
+      import JSONAPISerializer from '@ember-data/serializer/json-api';
+      import { underscore } from '<app-name>/utils/string-utils';
+  
+      export default class ApplicationSerializer extends JSONAPISerializer {
+        keyForRelationship(key, relationship, method) {
+          return underscore(key);
+        }
+      }
+      ```
+      @public
+     @param {String} key
+     @param {String} typeClass
+     @param {String} method
+     @return {String} normalized key
+    */
+    keyForRelationship(key: string, typeClass: string, method: string): string;
+    /**
+      Called when a record is saved in order to convert the
+      record into JSON.
+  
+      For example, consider this model:
+  
+      ```js [app/models/comment.js]
+      import Model, { attr, belongsTo } from '@ember-data/model';
+  
+      export default class CommentModel extends Model {
+        @attr title;
+        @attr body;
+  
+        @belongsTo('user', { async: false, inverse: null })
+        author;
+      }
+      ```
+  
+      The default serialization would create a JSON-API resource object like:
+  
+      ```javascript
+      {
+        "data": {
+          "type": "comments",
+          "attributes": {
+            "title": "Rails is unagi",
+            "body": "Rails? Omakase? O_O",
+          },
+          "relationships": {
+            "author": {
+              "data": {
+                "id": "12",
+                "type": "users"
+              }
+            }
+          }
+        }
+      }
+      ```
+  
+      By default, attributes are passed through as-is, unless
+      you specified an attribute type (`attr('date')`). If
+      you specify a transform, the JavaScript value will be
+      serialized when inserted into the attributes hash.
+  
+      Belongs-to relationships are converted into JSON-API
+      resource identifier objects.
+  
+      ## IDs
+  
+      `serialize` takes an options hash with a single option:
+      `includeId`. If this option is `true`, `serialize` will,
+      by default include the ID in the JSON object it builds.
+  
+      The JSONAPIAdapter passes in `includeId: true` when serializing a record
+      for `createRecord` or `updateRecord`.
+  
+      ## Customization
+  
+      Your server may expect data in a different format than the
+      built-in serialization format.
+  
+      In that case, you can implement `serialize` yourself and
+      return data formatted to match your API's expectations, or override
+      the invoked adapter method and do the serialization in the adapter directly
+      by using the provided snapshot.
+  
+      If your API's format differs greatly from the JSON:API spec, you should
+      consider authoring your own adapter and serializer instead of extending
+      this class.
+  
+      ```js [app/serializers/post.js]
+      import JSONAPISerializer from '@ember-data/serializer/json-api';
+  
+      export default class PostSerializer extends JSONAPISerializer {
+        serialize(snapshot, options) {
+          let json = {
+            POST_TTL: snapshot.attr('title'),
+            POST_BDY: snapshot.attr('body'),
+            POST_CMS: snapshot.hasMany('comments', { ids: true })
+          };
+  
+          if (options.includeId) {
+            json.POST_ID_ = snapshot.id;
+          }
+  
+          return json;
+        }
+      }
+      ```
+  
+      ## Customizing an App-Wide Serializer
+  
+      If you want to define a serializer for your entire
+      application, you'll probably want to use `eachAttribute`
+      and `eachRelationship` on the record.
+  
+      ```js [app/serializers/application.js]
+      import JSONAPISerializer from '@ember-data/serializer/json-api';
+      import { underscore, singularize } from '<app-name>/utils/string-utils';
+  
+      export default class ApplicationSerializer extends JSONAPISerializer {
+        serialize(snapshot, options) {
+          let json = {};
+  
+          snapshot.eachAttribute((name) => {
+            json[serverAttributeName(name)] = snapshot.attr(name);
+          });
+  
+          snapshot.eachRelationship((name, relationship) => {
+            if (relationship.kind === 'hasMany') {
+              json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+            }
+          });
+  
+          if (options.includeId) {
+            json.ID_ = snapshot.id;
+          }
+  
+          return json;
+        }
+      }
+  
+      function serverAttributeName(attribute) {
+        return underscore(attribute).toUpperCase();
+      }
+  
+      function serverHasManyName(name) {
+        return serverAttributeName(singularize(name)) + '_IDS';
+      }
+      ```
+  
+      This serializer will generate JSON that looks like this:
+  
+      ```javascript
+      {
+        "TITLE": "Rails is omakase",
+        "BODY": "Yep. Omakase.",
+        "COMMENT_IDS": [ "1", "2", "3" ]
+      }
+      ```
+  
+      ## Tweaking the Default Formatting
+  
+      If you just want to do some small tweaks on the default JSON:API formatted response,
+      you can call `super.serialize` first and make the tweaks
+      on the returned object.
+  
+      ```js [app/serializers/post.js]
+      import JSONAPISerializer from '@ember-data/serializer/json-api';
+  
+      export default class PostSerializer extends JSONAPISerializer {
+        serialize(snapshot, options) {
+          let json = super.serialize(...arguments);
+  
+          json.data.attributes.subject = json.data.attributes.title;
+          delete json.data.attributes.title;
+  
+          return json;
+        }
+      }
+      ```
+  
+      @public
+      @param {Snapshot} snapshot
+      @param {Object} options
+      @return {Object} json
+    */
+    serialize(snapshot: Snapshot, options: any, ...args: any[]): any;
+    serializeAttribute(snapshot: any, json: any, key: any, attribute: any): void;
+    serializeBelongsTo(snapshot: any, json: any, relationship: any): void;
+    serializeHasMany(snapshot: any, json: any, relationship: any): void;
+};
+//# sourceMappingURL=json-api.d.ts.map

package/declarations/serializer/json-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-api.d.ts","sourceRoot":"","sources":["../../src/serializer/json-api.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0HE;AACF;;;+BA0FY,KAAK;6BAiCiS,KAAK,qBAAoB,KAAK;uCAgD3U,KAAK,qBAEN,KAAA;wCAOe,KACjB,qBACU,KAAA;oCAI6R,KAAK,qBAAoB,KAAK;0CAsBvR,KAAK,qBACjD,KAAG;wCAgBW,KAAK,qBAAoB,KAAK;qCAiBrB,KAAK,qBAAqB,KAAI;kCAgBjD,KAAK,qBAIT,KAAC;yCAWc,KAAK,qBAAoB,KAAK;yCAoBrC,KAAK,qBAAoB,KAAK;yCAY5B,KAAK,qBAAoB,KAAK;iCAoBnC,KAAK,qBAEH,KAAK;mCAmBO,KACvB,qBAAoB,KACnB;kCAoBK,KAAK,qBAAoB,KAAK;8BAUV,KAAK,qBAEvB,KAAK;;;;;;;;;;;;;qCA+OotJ,QAAQ,6BAA+C,kBAAkB;wBAA06I,QAAQ;4CAAksD,KAAK,YAAwB,QAAQ;iCAAs0B,QAAQ;iCAAk5C,QAAQ;+BAAy8C,QAAQ;;uBAAs5E,KAAK,cAAoB,KAAK;yBAAw7E,KAAK,aAAoB,KAAK;;;;iEAA88G,SAAS;;IA1mB39tB;;;;MAIE;;IAgCF;;;;MAIE;;IAOF;;;;MAIE;;IAqBF;;;;;;MAME;uBAFQ,KAAK;IAQf;;;;;;;;;MASE;8BARQ,KAAK,qBACL,KAAK,oBAEL,eAAa;;;IA6CvB;;;;;;;;MAQE;;IAkBF;;;;;;;;;MASE;;IA4BF;;;;;MAKE;6BAJQ,KAAK;IASf;;;;;;;;;;MAUE;;IAKF;;;;;;;;;MASE;;;;;;;;;;IA8BF;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;;IAKF;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;;IAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuKE;wBAHQ,QAAQ;;;;EAiGjB"}