@ember-data-mirror/serializer 5.4.0-alpha.49

package/unstable-preview-types/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.js"],"names":[],"mappings":"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"}

package/unstable-preview-types/rest.d.ts

@@ -0,0 +1,602 @@
+declare module '@ember-data-mirror/serializer/rest' {
+  /// <reference types="ember-source/types" />
+  export { EmbeddedRecordsMixin } from "./-private";
+  export default RESTSerializer;
+  /**
+   * <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>
+  
+    Normally, applications will use the `RESTSerializer` by implementing
+    the `normalize` method.
+  
+    This allows you to do whatever kind of munging you need and is
+    especially useful if your server is inconsistent and you need to
+    do munging differently for many different kinds of responses.
+  
+    See the `normalize` documentation for more information.
+  
+    ## Across the Board Normalization
+  
+    There are also a number of hooks that you might find useful to define
+    across-the-board rules for your payload. These rules will be useful
+    if your server is consistent, or if you're building an adapter for
+    an infrastructure service, like Firebase, and want to encode service
+    conventions.
+  
+    For example, if all of your keys are underscored and all-caps, but
+    otherwise consistent with the names you use in your models, you
+    can implement across-the-board rules for how to convert an attribute
+    name in your model to a key in your JSON.
+  
+    ```app/serializers/application.js
+    import RESTSerializer from '@ember-data-mirror/serializer/rest';
+    import { underscore } from '<app-name>/utils/string-utils';
+  
+    export default class ApplicationSerializer extends RESTSerializer {
+      keyForAttribute(attr, method) {
+        return underscore(attr).toUpperCase();
+      }
+    }
+    ```
+  
+    You can also implement `keyForRelationship`, which takes the name
+    of the relationship as the first parameter, the kind of
+    relationship (`hasMany` or `belongsTo`) as the second parameter, and
+    the method (`serialize` or `deserialize`) as the third parameter.
+  
+    @class RESTSerializer
+    @main @ember-data-mirror/serializer/rest
+    @public
+    @extends JSONSerializer
+  */
+  const RESTSerializer: Readonly<Readonly<typeof import("@ember-data-mirror/serializer").default> & (new (owner?: import("@ember/-internals/owner").default | undefined) => import(".").default) & {
+      primaryKey: string;
+      mergedProperties: Object;
+      applyTransforms(typeClass: Model, data: Object): Object;
+      normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object; /**
+        This method allows you to push a payload containing top-level
+        collections of records organized per type.
+    
+        ```js
+        {
+          "posts": [{
+            "id": "1",
+            "title": "Rails is omakase",
+            "author", "1",
+            "comments": [ "1" ]
+          }],
+          "comments": [{
+            "id": "1",
+            "body": "FIRST"
+          }],
+          "users": [{
+            "id": "1",
+            "name": "@d2h"
+          }]
+        }
+        ```
+    
+        It will first normalize the payload, so you can use this to push
+        in data streaming in from your server structured the same way
+        that fetches and saves are structured.
+    
+        @method pushPayload
+        @public
+        @param {Store} store
+        @param {Object} payload
+      */
+      normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
+      normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
+      _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
+      normalize(modelClass: any, resourceHash: any): Object;
+      extractId(modelClass: Object, resourceHash: Object): string;
+      extractAttributes(modelClass: Object, resourceHash: Object): Object;
+      extractRelationship(relationshipModelName: Object, relationshipHash: Object): Object;
+      extractPolymorphicRelationship(relationshipModelName: Object, relationshipHash: Object, relationshipOptions: Object): Object;
+      extractRelationships(modelClass: Object, resourceHash: Object): Object;
+      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: Object): Object;
+      serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
+      serializeAttribute(snapshot: Snapshot, json: Object, key: string, attribute: Object): void;
+      serializeBelongsTo(snapshot: Snapshot, json: Object, relationship: Object): void;
+      serializeHasMany(snapshot: Snapshot, json: Object, relationship: Object): void;
+      serializePolymorphicType(): void;
+      extractMeta(store: Store, modelClass: Model, payload: Object): any;
+      extractErrors(store: Store, typeClass: Model, payload: Object, id: string | number): Object;
+      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-data-mirror/serializer/@ember/-internals/owner").default | undefined) => import(".").default) & {
+      /**
+       `keyForPolymorphicType` can be used to define a custom key when
+       serializing and deserializing a polymorphic type. By default, the
+       returned key is `${key}Type`.
+    
+       Example
+    
+        ```app/serializers/post.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          keyForPolymorphicType(key, relationship) {
+            let relationshipKey = this.keyForRelationship(key);
+    
+            return 'type-' + relationshipKey;
+          }
+        }
+        ```
+    
+       @method keyForPolymorphicType
+        @public
+       @param {String} key
+       @param {String} typeClass
+       @param {String} method
+       @return {String} normalized key
+      */
+      keyForPolymorphicType(key: string, typeClass: string, method: string): string;
+      /**
+        Normalizes a part of the JSON payload returned by
+        the server. You should override this method, munge the hash
+        and call super if you have generic normalization to do.
+    
+        It takes the type of the record that is being normalized
+        (as a Model class), the property where the hash was
+        originally found, and the hash to normalize.
+    
+        For example, if you have a payload that looks like this:
+    
+        ```js
+        {
+          "post": {
+            "id": 1,
+            "title": "Rails is omakase",
+            "comments": [ 1, 2 ]
+          },
+          "comments": [{
+            "id": 1,
+            "body": "FIRST"
+          }, {
+            "id": 2,
+            "body": "Rails is unagi"
+          }]
+        }
+        ```
+    
+        The `normalize` method will be called three times:
+    
+        * With `App.Post`, `"posts"` and `{ id: 1, title: "Rails is omakase", ... }`
+        * With `App.Comment`, `"comments"` and `{ id: 1, body: "FIRST" }`
+        * With `App.Comment`, `"comments"` and `{ id: 2, body: "Rails is unagi" }`
+    
+        You can use this method, for example, to normalize underscored keys to camelized
+        or other general-purpose normalizations. You will only need to implement
+        `normalize` and manipulate the payload as desired.
+    
+        For example, if the `IDs` under `"comments"` are provided as `_id` instead of
+        `id`, you can specify how to normalize just the comments:
+    
+        ```app/serializers/post.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          normalize(model, hash, prop) {
+            if (prop === 'comments') {
+              hash.id = hash._id;
+              delete hash._id;
+            }
+    
+            return super.normalize(...arguments);
+          }
+        }
+        ```
+    
+        On each call to the `normalize` method, the third parameter (`prop`) is always
+        one of the keys that were in the original payload or in the result of another
+        normalization as `normalizeResponse`.
+    
+        @method normalize
+        @public
+        @param {Model} modelClass
+        @param {Object} resourceHash
+        @param {String} prop
+        @return {Object}
+      */
+      /**
+        Normalizes an array of resource payloads and returns a JSON-API Document
+        with primary data and, if any, included data as `{ data, included }`.
+    
+        @method _normalizeArray
+        @param {Store} store
+        @param {String} modelName
+        @param {Object} arrayHash
+        @param {String} prop
+        @return {Object}
+        @private
+      */
+      _normalizeArray(store: Store, modelName: string, arrayHash: Object, prop: string): Object;
+      _normalizePolymorphicRecord(store: any, hash: any, prop: any, primaryModelClass: any, primarySerializer: any): any;
+      /**
+        @method _normalizeResponse
+        @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: Object, id: string | number, requestType: string, isSingle: boolean): Object;
+      isPrimaryType(store: any, modelName: any, primaryModelClass: any): boolean;
+      /**
+        This method allows you to push a payload containing top-level
+        collections of records organized per type.
+    
+        ```js
+        {
+          "posts": [{
+            "id": "1",
+            "title": "Rails is omakase",
+            "author", "1",
+            "comments": [ "1" ]
+          }],
+          "comments": [{
+            "id": "1",
+            "body": "FIRST"
+          }],
+          "users": [{
+            "id": "1",
+            "name": "@d2h"
+          }]
+        }
+        ```
+    
+        It will first normalize the payload, so you can use this to push
+        in data streaming in from your server structured the same way
+        that fetches and saves are structured.
+    
+        @method pushPayload
+        @public
+        @param {Store} store
+        @param {Object} payload
+      */
+      pushPayload(store: Store, payload: Object): void;
+      /**
+        This method is used to convert each JSON root key in the payload
+        into a modelName that it can use to look up the appropriate model for
+        that part of the payload.
+    
+        For example, your server may send a model name that does not correspond with
+        the name of the model in your app. Let's take a look at an example model,
+        and an example payload:
+    
+        ```app/models/post.js
+        import Model from '@ember-data-mirror/model';
+    
+        export default class Post extends Model {}
+        ```
+    
+        ```javascript
+          {
+            "blog/post": {
+              "id": "1
+            }
+          }
+        ```
+    
+        Ember Data is going to normalize the payload's root key for the modelName. As a result,
+        it will try to look up the "blog/post" model. Since we don't have a model called "blog/post"
+        (or a file called app/models/blog/post.js in ember-cli), Ember Data will throw an error
+        because it cannot find the "blog/post" model.
+    
+        Since we want to remove this namespace, we can define a serializer for the application that will
+        remove "blog/" from the payload key whenver it's encountered by Ember Data:
+    
+        ```app/serializers/application.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          modelNameFromPayloadKey(payloadKey) {
+            if (payloadKey === 'blog/post') {
+              return super.modelNameFromPayloadKey(payloadKey.replace('blog/', ''));
+            } else {
+             return super.modelNameFromPayloadKey(payloadKey);
+            }
+          }
+        }
+        ```
+    
+        After refreshing, Ember Data will appropriately look up the "post" model.
+    
+        By default the modelName for a model is its
+        name in dasherized form. This means that a payload key like "blogPost" would be
+        normalized to "blog-post" when Ember Data looks up the model. Usually, Ember Data
+        can use the correct inflection to do this for you. Most of the time, you won't
+        need to override `modelNameFromPayloadKey` for this purpose.
+    
+        @method modelNameFromPayloadKey
+        @public
+        @param {String} key
+        @return {String} the model's modelName
+      */
+      modelNameFromPayloadKey(key: string): string;
+      /**
+        Called when a record is saved in order to convert the
+        record into JSON.
+    
+        By default, it creates a JSON object with a key for
+        each attribute and belongsTo relationship.
+    
+        For example, consider this model:
+    
+        ```app/models/comment.js
+        import Model, { attr, belongsTo } from '@ember-data-mirror/model';
+    
+        export default class Comment extends Model {
+          @attr title
+          @attr body
+    
+          @belongsTo('user') author
+        }
+        ```
+    
+        The default serialization would create a JSON object like:
+    
+        ```js
+        {
+          "title": "Rails is unagi",
+          "body": "Rails? Omakase? O_O",
+          "author": 12
+        }
+        ```
+    
+        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 JSON hash.
+    
+        By default, belongs-to relationships are converted into
+        IDs when inserted into the JSON hash.
+    
+        ## 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 adapter passes in `includeId: true` when serializing
+        a record for `createRecord`, but not for `updateRecord`.
+    
+        ## Customization
+    
+        Your server may expect a different JSON format than the
+        built-in serialization format.
+    
+        In that case, you can implement `serialize` yourself and
+        return a JSON hash of your choosing.
+    
+        ```app/serializers/post.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          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.
+    
+        ```app/serializers/application.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+        import { pluralize } from '<app-name>/utils/string-utils';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          serialize(snapshot, options) {
+            let json = {};
+    
+            snapshot.eachAttribute(function(name) {
+              json[serverAttributeName(name)] = snapshot.attr(name);
+            });
+    
+            snapshot.eachRelationship(function(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 attribute.underscore().toUpperCase();
+        }
+    
+        function serverHasManyName(name) {
+          return serverAttributeName(singularize(name)) + "_IDS";
+        }
+        ```
+    
+        This serializer will generate JSON that looks like this:
+    
+        ```js
+        {
+          "TITLE": "Rails is omakase",
+          "BODY": "Yep. Omakase.",
+          "COMMENT_IDS": [ 1, 2, 3 ]
+        }
+        ```
+    
+        ## Tweaking the Default JSON
+    
+        If you just want to do some small tweaks on the default JSON,
+        you can call super first and make the tweaks on the returned
+        JSON.
+    
+        ```app/serializers/post.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          serialize(snapshot, options) {
+            let json = super.serialize(snapshot, options);
+    
+            json.subject = json.title;
+            delete json.title;
+    
+            return json;
+          }
+        }
+        ```
+    
+        @method serialize
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} options
+        @return {Object} json
+      */
+      serialize(snapshot: Snapshot, options: Object, ...args: any[]): Object;
+      /**
+        You can use this method to customize the root keys serialized into the JSON.
+        The hash property should be modified by reference (possibly using something like _.extend)
+        By default the REST Serializer sends the modelName of a model, which is a camelized
+        version of the name.
+    
+        For example, your server may expect underscored root objects.
+    
+        ```app/serializers/application.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+        import { decamelize } from '<app-name>/utils/string-utils';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          serializeIntoHash(data, type, record, options) {
+            let root = decamelize(type.modelName);
+            data[root] = this.serialize(record, options);
+          }
+        }
+        ```
+    
+        @method serializeIntoHash
+        @public
+        @param {Object} hash
+        @param {Model} typeClass
+        @param {Snapshot} snapshot
+        @param {Object} options
+      */
+      serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
+      /**
+        You can use `payloadKeyFromModelName` to override the root key for an outgoing
+        request. By default, the RESTSerializer returns a camelized version of the
+        model's name.
+    
+        For a model called TacoParty, its `modelName` would be the string `taco-party`. The RESTSerializer
+        will send it to the server with `tacoParty` as the root key in the JSON payload:
+    
+        ```js
+        {
+          "tacoParty": {
+            "id": "1",
+            "location": "Matthew Beale's House"
+          }
+        }
+        ```
+    
+        For example, your server may expect dasherized root objects:
+    
+        ```app/serializers/application.js
+        import RESTSerializer from '@ember-data-mirror/serializer/rest';
+        import { dasherize } from '<app-name>/utils/string-utils';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          payloadKeyFromModelName(modelName) {
+            return dasherize(modelName);
+          }
+        }
+        ```
+    
+        Given a `TacoParty` model, calling `save` on it would produce an outgoing
+        request like:
+    
+        ```js
+        {
+          "taco-party": {
+            "id": "1",
+            "location": "Matthew Beale's House"
+          }
+        }
+        ```
+    
+        @method payloadKeyFromModelName
+        @public
+        @param {String} modelName
+        @return {String}
+      */
+      payloadKeyFromModelName(modelName: string): string;
+      /**
+        You can use this method to customize how polymorphic objects are serialized.
+        By default the REST Serializer creates the key by appending `Type` to
+        the attribute and value from the model's camelcased model name.
+    
+        @method serializePolymorphicType
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializePolymorphicType(snapshot: Snapshot, json: Object, relationship: Object): void;
+      /**
+        You can use this method to customize how a polymorphic relationship should
+        be extracted.
+    
+        @method extractPolymorphicRelationship
+        @public
+        @param {Object} relationshipType
+        @param {Object} relationshipHash
+        @param {Object} relationshipOptions
+        @return {Object}
+       */
+      extractPolymorphicRelationship(relationshipType: Object, relationshipHash: Object, relationshipOptions: Object, ...args: any[]): Object;
+  };
+}
+//# sourceMappingURL=rest.d.ts.map

package/unstable-preview-types/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../src/rest.js"],"names":[],"mappings":";;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDE;AACF;;;;;;;;+JAsSE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IApUF;;;;;;;;;;;;;;;;;;;;;;;;;MAyBE;;IAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkEE;IAEF;;;;;;;;;;;MAWE;gEAJQ,MAAM,iBAEL,MAAM;;IA0CjB;;;;;;;;;;MAUE;wEANQ,MAAM,MACN,eAAa,2CAGZ,MAAM;;IAsIjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;uCADQ,MAAM;IA+BhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyDE;;IAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwJE;2CAFQ,MAAM,mBACL,MAAM;IAMjB;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;4BAJQ,MAAM,iDAGN,MAAM;IAOhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8CE;;IAKF;;;;;;;;;;MAUE;uDAFQ,MAAM,gBACN,MAAM;IAchB;;;;;;;;;;OAUG;qDAJO,MAAM,oBACN,MAAM,uBACN,MAAM,mBACL,MAAM;EAmChB"}

package/unstable-preview-types/transform.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember-data-mirror/serializer/transform' {
+  /**
+    @module @ember-data-mirror/serializer
+  */
+  export { Transform as default, BooleanTransform, DateTransform, NumberTransform, StringTransform } from '@ember-data-mirror/serializer/-private';
+}
+//# sourceMappingURL=transform.d.ts.map

package/unstable-preview-types/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA;;EAEE;AACF,OAAO,EAAE,SAAS,IAAI,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}