1 | System.register("class-transformer/ClassTransformOptions", [], function (exports_1, context_1) {
|
2 | "use strict";
|
3 | var __moduleName = context_1 && context_1.id;
|
4 | return {
|
5 | setters: [],
|
6 | execute: function () {
|
7 | }
|
8 | };
|
9 | });
|
10 | System.register("class-transformer/metadata/ExposeExcludeOptions", [], function (exports_2, context_2) {
|
11 | "use strict";
|
12 | var __moduleName = context_2 && context_2.id;
|
13 | return {
|
14 | setters: [],
|
15 | execute: function () {
|
16 | }
|
17 | };
|
18 | });
|
19 | System.register("class-transformer/metadata/TypeMetadata", [], function (exports_3, context_3) {
|
20 | "use strict";
|
21 | var TypeMetadata;
|
22 | var __moduleName = context_3 && context_3.id;
|
23 | return {
|
24 | setters: [],
|
25 | execute: function () {
|
26 | TypeMetadata = (function () {
|
27 | function TypeMetadata(target, propertyName, reflectedType, typeFunction, options) {
|
28 | this.target = target;
|
29 | this.propertyName = propertyName;
|
30 | this.reflectedType = reflectedType;
|
31 | this.typeFunction = typeFunction;
|
32 | this.options = options;
|
33 | }
|
34 | return TypeMetadata;
|
35 | }());
|
36 | exports_3("TypeMetadata", TypeMetadata);
|
37 | }
|
38 | };
|
39 | });
|
40 | System.register("class-transformer/metadata/ExposeMetadata", [], function (exports_4, context_4) {
|
41 | "use strict";
|
42 | var ExposeMetadata;
|
43 | var __moduleName = context_4 && context_4.id;
|
44 | return {
|
45 | setters: [],
|
46 | execute: function () {
|
47 | ExposeMetadata = (function () {
|
48 | function ExposeMetadata(target, propertyName, options) {
|
49 | this.target = target;
|
50 | this.propertyName = propertyName;
|
51 | this.options = options;
|
52 | }
|
53 | return ExposeMetadata;
|
54 | }());
|
55 | exports_4("ExposeMetadata", ExposeMetadata);
|
56 | }
|
57 | };
|
58 | });
|
59 | System.register("class-transformer/metadata/ExcludeMetadata", [], function (exports_5, context_5) {
|
60 | "use strict";
|
61 | var ExcludeMetadata;
|
62 | var __moduleName = context_5 && context_5.id;
|
63 | return {
|
64 | setters: [],
|
65 | execute: function () {
|
66 | ExcludeMetadata = (function () {
|
67 | function ExcludeMetadata(target, propertyName, options) {
|
68 | this.target = target;
|
69 | this.propertyName = propertyName;
|
70 | this.options = options;
|
71 | }
|
72 | return ExcludeMetadata;
|
73 | }());
|
74 | exports_5("ExcludeMetadata", ExcludeMetadata);
|
75 | }
|
76 | };
|
77 | });
|
78 | System.register("class-transformer/metadata/TransformMetadata", [], function (exports_6, context_6) {
|
79 | "use strict";
|
80 | var TransformMetadata;
|
81 | var __moduleName = context_6 && context_6.id;
|
82 | return {
|
83 | setters: [],
|
84 | execute: function () {
|
85 | TransformMetadata = (function () {
|
86 | function TransformMetadata(target, propertyName, transformFn, options) {
|
87 | this.target = target;
|
88 | this.propertyName = propertyName;
|
89 | this.transformFn = transformFn;
|
90 | this.options = options;
|
91 | }
|
92 | return TransformMetadata;
|
93 | }());
|
94 | exports_6("TransformMetadata", TransformMetadata);
|
95 | }
|
96 | };
|
97 | });
|
98 | System.register("class-transformer/metadata/MetadataStorage", ["class-transformer/TransformOperationExecutor"], function (exports_7, context_7) {
|
99 | "use strict";
|
100 | var TransformOperationExecutor_1, MetadataStorage;
|
101 | var __moduleName = context_7 && context_7.id;
|
102 | return {
|
103 | setters: [
|
104 | function (TransformOperationExecutor_1_1) {
|
105 | TransformOperationExecutor_1 = TransformOperationExecutor_1_1;
|
106 | }
|
107 | ],
|
108 | execute: function () {
|
109 | |
110 |
|
111 |
|
112 | MetadataStorage = (function () {
|
113 | function MetadataStorage() {
|
114 |
|
115 |
|
116 |
|
117 | this._typeMetadatas = new Map();
|
118 | this._transformMetadatas = new Map();
|
119 | this._exposeMetadatas = new Map();
|
120 | this._excludeMetadatas = new Map();
|
121 | this._ancestorsMap = new Map();
|
122 | }
|
123 |
|
124 |
|
125 |
|
126 | MetadataStorage.prototype.addTypeMetadata = function (metadata) {
|
127 | if (!this._typeMetadatas.has(metadata.target)) {
|
128 | this._typeMetadatas.set(metadata.target, new Map());
|
129 | }
|
130 | this._typeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);
|
131 | };
|
132 | MetadataStorage.prototype.addTransformMetadata = function (metadata) {
|
133 | if (!this._transformMetadatas.has(metadata.target)) {
|
134 | this._transformMetadatas.set(metadata.target, new Map());
|
135 | }
|
136 | if (!this._transformMetadatas.get(metadata.target).has(metadata.propertyName)) {
|
137 | this._transformMetadatas.get(metadata.target).set(metadata.propertyName, []);
|
138 | }
|
139 | this._transformMetadatas.get(metadata.target).get(metadata.propertyName).push(metadata);
|
140 | };
|
141 | MetadataStorage.prototype.addExposeMetadata = function (metadata) {
|
142 | if (!this._exposeMetadatas.has(metadata.target)) {
|
143 | this._exposeMetadatas.set(metadata.target, new Map());
|
144 | }
|
145 | this._exposeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);
|
146 | };
|
147 | MetadataStorage.prototype.addExcludeMetadata = function (metadata) {
|
148 | if (!this._excludeMetadatas.has(metadata.target)) {
|
149 | this._excludeMetadatas.set(metadata.target, new Map());
|
150 | }
|
151 | this._excludeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);
|
152 | };
|
153 |
|
154 |
|
155 |
|
156 | MetadataStorage.prototype.findTransformMetadatas = function (target, propertyName, transformationType) {
|
157 | return this.findMetadatas(this._transformMetadatas, target, propertyName)
|
158 | .filter(function (metadata) {
|
159 | if (!metadata.options)
|
160 | return true;
|
161 | if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)
|
162 | return true;
|
163 | if (metadata.options.toClassOnly === true) {
|
164 | return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_CLASS || transformationType === TransformOperationExecutor_1.TransformationType.PLAIN_TO_CLASS;
|
165 | }
|
166 | if (metadata.options.toPlainOnly === true) {
|
167 | return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_PLAIN;
|
168 | }
|
169 | return true;
|
170 | });
|
171 | };
|
172 | MetadataStorage.prototype.findExcludeMetadata = function (target, propertyName) {
|
173 | return this.findMetadata(this._excludeMetadatas, target, propertyName);
|
174 | };
|
175 | MetadataStorage.prototype.findExposeMetadata = function (target, propertyName) {
|
176 | return this.findMetadata(this._exposeMetadatas, target, propertyName);
|
177 | };
|
178 | MetadataStorage.prototype.findExposeMetadataByCustomName = function (target, name) {
|
179 | return this.getExposedMetadatas(target).find(function (metadata) {
|
180 | return metadata.options && metadata.options.name === name;
|
181 | });
|
182 | };
|
183 | MetadataStorage.prototype.findTypeMetadata = function (target, propertyName) {
|
184 | return this.findMetadata(this._typeMetadatas, target, propertyName);
|
185 | };
|
186 | MetadataStorage.prototype.getStrategy = function (target) {
|
187 | var excludeMap = this._excludeMetadatas.get(target);
|
188 | var exclude = excludeMap && excludeMap.get(undefined);
|
189 | var exposeMap = this._exposeMetadatas.get(target);
|
190 | var expose = exposeMap && exposeMap.get(undefined);
|
191 | if ((exclude && expose) || (!exclude && !expose))
|
192 | return "none";
|
193 | return exclude ? "excludeAll" : "exposeAll";
|
194 | };
|
195 | MetadataStorage.prototype.getExposedMetadatas = function (target) {
|
196 | return this.getMetadata(this._exposeMetadatas, target);
|
197 | };
|
198 | MetadataStorage.prototype.getExcludedMetadatas = function (target) {
|
199 | return this.getMetadata(this._excludeMetadatas, target);
|
200 | };
|
201 | MetadataStorage.prototype.getExposedProperties = function (target, transformationType) {
|
202 | return this.getExposedMetadatas(target)
|
203 | .filter(function (metadata) {
|
204 | if (!metadata.options)
|
205 | return true;
|
206 | if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)
|
207 | return true;
|
208 | if (metadata.options.toClassOnly === true) {
|
209 | return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_CLASS || transformationType === TransformOperationExecutor_1.TransformationType.PLAIN_TO_CLASS;
|
210 | }
|
211 | if (metadata.options.toPlainOnly === true) {
|
212 | return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_PLAIN;
|
213 | }
|
214 | return true;
|
215 | })
|
216 | .map(function (metadata) { return metadata.propertyName; });
|
217 | };
|
218 | MetadataStorage.prototype.getExcludedProperties = function (target, transformationType) {
|
219 | return this.getExcludedMetadatas(target)
|
220 | .filter(function (metadata) {
|
221 | if (!metadata.options)
|
222 | return true;
|
223 | if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)
|
224 | return true;
|
225 | if (metadata.options.toClassOnly === true) {
|
226 | return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_CLASS || transformationType === TransformOperationExecutor_1.TransformationType.PLAIN_TO_CLASS;
|
227 | }
|
228 | if (metadata.options.toPlainOnly === true) {
|
229 | return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_PLAIN;
|
230 | }
|
231 | return true;
|
232 | })
|
233 | .map(function (metadata) { return metadata.propertyName; });
|
234 | };
|
235 | MetadataStorage.prototype.clear = function () {
|
236 | this._typeMetadatas.clear();
|
237 | this._exposeMetadatas.clear();
|
238 | this._excludeMetadatas.clear();
|
239 | this._ancestorsMap.clear();
|
240 | };
|
241 |
|
242 |
|
243 |
|
244 | MetadataStorage.prototype.getMetadata = function (metadatas, target) {
|
245 | var metadataFromTargetMap = metadatas.get(target);
|
246 | var metadataFromTarget;
|
247 | if (metadataFromTargetMap) {
|
248 | metadataFromTarget = Array.from(metadataFromTargetMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });
|
249 | }
|
250 | var metadataFromAncestors = [];
|
251 | for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {
|
252 | var ancestor = _a[_i];
|
253 | var ancestorMetadataMap = metadatas.get(ancestor);
|
254 | if (ancestorMetadataMap) {
|
255 | var metadataFromAncestor = Array.from(ancestorMetadataMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });
|
256 | metadataFromAncestors.push.apply(metadataFromAncestors, metadataFromAncestor);
|
257 | }
|
258 | }
|
259 | return metadataFromAncestors.concat(metadataFromTarget || []);
|
260 | };
|
261 | MetadataStorage.prototype.findMetadata = function (metadatas, target, propertyName) {
|
262 | var metadataFromTargetMap = metadatas.get(target);
|
263 | if (metadataFromTargetMap) {
|
264 | var metadataFromTarget = metadataFromTargetMap.get(propertyName);
|
265 | if (metadataFromTarget) {
|
266 | return metadataFromTarget;
|
267 | }
|
268 | }
|
269 | for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {
|
270 | var ancestor = _a[_i];
|
271 | var ancestorMetadataMap = metadatas.get(ancestor);
|
272 | if (ancestorMetadataMap) {
|
273 | var ancestorResult = ancestorMetadataMap.get(propertyName);
|
274 | if (ancestorResult) {
|
275 | return ancestorResult;
|
276 | }
|
277 | }
|
278 | }
|
279 | return undefined;
|
280 | };
|
281 | MetadataStorage.prototype.findMetadatas = function (metadatas, target, propertyName) {
|
282 | var metadataFromTargetMap = metadatas.get(target);
|
283 | var metadataFromTarget;
|
284 | if (metadataFromTargetMap) {
|
285 | metadataFromTarget = metadataFromTargetMap.get(propertyName);
|
286 | }
|
287 | var metadataFromAncestorsTarget = [];
|
288 | for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {
|
289 | var ancestor = _a[_i];
|
290 | var ancestorMetadataMap = metadatas.get(ancestor);
|
291 | if (ancestorMetadataMap) {
|
292 | if (ancestorMetadataMap.has(propertyName)) {
|
293 | metadataFromAncestorsTarget.push.apply(metadataFromAncestorsTarget, ancestorMetadataMap.get(propertyName));
|
294 | }
|
295 | }
|
296 | }
|
297 | return (metadataFromAncestorsTarget).reverse().concat((metadataFromTarget || []).reverse());
|
298 | };
|
299 | MetadataStorage.prototype.getAncestors = function (target) {
|
300 | if (!target)
|
301 | return [];
|
302 | if (!this._ancestorsMap.has(target)) {
|
303 | var ancestors = [];
|
304 | for (var baseClass = Object.getPrototypeOf(target.prototype.constructor); typeof baseClass.prototype !== "undefined"; baseClass = Object.getPrototypeOf(baseClass.prototype.constructor)) {
|
305 | ancestors.push(baseClass);
|
306 | }
|
307 | this._ancestorsMap.set(target, ancestors);
|
308 | }
|
309 | return this._ancestorsMap.get(target);
|
310 | };
|
311 | return MetadataStorage;
|
312 | }());
|
313 | exports_7("MetadataStorage", MetadataStorage);
|
314 | }
|
315 | };
|
316 | });
|
317 | System.register("class-transformer/storage", ["class-transformer/metadata/MetadataStorage"], function (exports_8, context_8) {
|
318 | "use strict";
|
319 | var MetadataStorage_1, defaultMetadataStorage;
|
320 | var __moduleName = context_8 && context_8.id;
|
321 | return {
|
322 | setters: [
|
323 | function (MetadataStorage_1_1) {
|
324 | MetadataStorage_1 = MetadataStorage_1_1;
|
325 | }
|
326 | ],
|
327 | execute: function () {
|
328 | |
329 |
|
330 |
|
331 | exports_8("defaultMetadataStorage", defaultMetadataStorage = new MetadataStorage_1.MetadataStorage());
|
332 | }
|
333 | };
|
334 | });
|
335 | System.register("class-transformer/TransformOperationExecutor", ["class-transformer/storage"], function (exports_9, context_9) {
|
336 | "use strict";
|
337 | var storage_1, TransformationType, TransformOperationExecutor;
|
338 | var __moduleName = context_9 && context_9.id;
|
339 | function instantiateArrayType(arrayType) {
|
340 | var array = new arrayType();
|
341 | if (!(array instanceof Set) && !("push" in array)) {
|
342 | return [];
|
343 | }
|
344 | return array;
|
345 | }
|
346 | function testForBuffer() {
|
347 | try {
|
348 | Buffer;
|
349 | return true;
|
350 | }
|
351 | catch (_a) { }
|
352 | return false;
|
353 | }
|
354 | exports_9("testForBuffer", testForBuffer);
|
355 | return {
|
356 | setters: [
|
357 | function (storage_1_1) {
|
358 | storage_1 = storage_1_1;
|
359 | }
|
360 | ],
|
361 | execute: function () {
|
362 | (function (TransformationType) {
|
363 | TransformationType[TransformationType["PLAIN_TO_CLASS"] = 0] = "PLAIN_TO_CLASS";
|
364 | TransformationType[TransformationType["CLASS_TO_PLAIN"] = 1] = "CLASS_TO_PLAIN";
|
365 | TransformationType[TransformationType["CLASS_TO_CLASS"] = 2] = "CLASS_TO_CLASS";
|
366 | })(TransformationType || (TransformationType = {}));
|
367 | exports_9("TransformationType", TransformationType);
|
368 | TransformOperationExecutor = (function () {
|
369 |
|
370 |
|
371 |
|
372 | function TransformOperationExecutor(transformationType, options) {
|
373 | this.transformationType = transformationType;
|
374 | this.options = options;
|
375 |
|
376 |
|
377 |
|
378 | this.recursionStack = new Set();
|
379 | }
|
380 |
|
381 |
|
382 |
|
383 | TransformOperationExecutor.prototype.transform = function (source, value, targetType, arrayType, isMap, level) {
|
384 | var _this = this;
|
385 | if (level === void 0) { level = 0; }
|
386 | if (Array.isArray(value) || value instanceof Set) {
|
387 | var newValue_1 = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS ? instantiateArrayType(arrayType) : [];
|
388 | value.forEach(function (subValue, index) {
|
389 | var subSource = source ? source[index] : undefined;
|
390 | if (!_this.options.enableCircularCheck || !_this.isCircular(subValue)) {
|
391 | var realTargetType = void 0;
|
392 | if (typeof targetType !== "function" && targetType && targetType.options && targetType.options.discriminator && targetType.options.discriminator.property && targetType.options.discriminator.subTypes) {
|
393 | if (_this.transformationType === TransformationType.PLAIN_TO_CLASS) {
|
394 | realTargetType = targetType.options.discriminator.subTypes.find(function (subType) { return subType.name === subValue[targetType.options.discriminator.property]; });
|
395 | var options = { newObject: newValue_1, object: subValue, property: undefined };
|
396 | var newType = targetType.typeFunction(options);
|
397 | realTargetType === undefined ? realTargetType = newType : realTargetType = realTargetType.value;
|
398 | if (!targetType.options.keepDiscriminatorProperty)
|
399 | delete subValue[targetType.options.discriminator.property];
|
400 | }
|
401 | if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {
|
402 | realTargetType = subValue.constructor;
|
403 | }
|
404 | if (_this.transformationType === TransformationType.CLASS_TO_PLAIN) {
|
405 | subValue[targetType.options.discriminator.property] = targetType.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;
|
406 | }
|
407 | }
|
408 | else {
|
409 | realTargetType = targetType;
|
410 | }
|
411 | var value_1 = _this.transform(subSource, subValue, realTargetType, undefined, subValue instanceof Map, level + 1);
|
412 | if (newValue_1 instanceof Set) {
|
413 | newValue_1.add(value_1);
|
414 | }
|
415 | else {
|
416 | newValue_1.push(value_1);
|
417 | }
|
418 | }
|
419 | else if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {
|
420 | if (newValue_1 instanceof Set) {
|
421 | newValue_1.add(subValue);
|
422 | }
|
423 | else {
|
424 | newValue_1.push(subValue);
|
425 | }
|
426 | }
|
427 | });
|
428 | return newValue_1;
|
429 | }
|
430 | else if (targetType === String && !isMap) {
|
431 | if (value === null || value === undefined)
|
432 | return value;
|
433 | return String(value);
|
434 | }
|
435 | else if (targetType === Number && !isMap) {
|
436 | if (value === null || value === undefined)
|
437 | return value;
|
438 | return Number(value);
|
439 | }
|
440 | else if (targetType === Boolean && !isMap) {
|
441 | if (value === null || value === undefined)
|
442 | return value;
|
443 | return Boolean(value);
|
444 | }
|
445 | else if ((targetType === Date || value instanceof Date) && !isMap) {
|
446 | if (value instanceof Date) {
|
447 | return new Date(value.valueOf());
|
448 | }
|
449 | if (value === null || value === undefined)
|
450 | return value;
|
451 | return new Date(value);
|
452 | }
|
453 | else if (testForBuffer() && (targetType === Buffer || value instanceof Buffer) && !isMap) {
|
454 | if (value === null || value === undefined)
|
455 | return value;
|
456 | return Buffer.from(value);
|
457 | }
|
458 | else if (typeof value === "object" && value !== null) {
|
459 |
|
460 | if (!targetType && value.constructor !== Object )
|
461 | targetType = value.constructor;
|
462 | if (!targetType && source)
|
463 | targetType = source.constructor;
|
464 | if (this.options.enableCircularCheck) {
|
465 |
|
466 | this.recursionStack.add(value);
|
467 | }
|
468 | var keys = this.getKeys(targetType, value);
|
469 | var newValue = source ? source : {};
|
470 | if (!source && (this.transformationType === TransformationType.PLAIN_TO_CLASS || this.transformationType === TransformationType.CLASS_TO_CLASS)) {
|
471 | if (isMap) {
|
472 | newValue = new Map();
|
473 | }
|
474 | else if (targetType) {
|
475 | newValue = new targetType();
|
476 | }
|
477 | else {
|
478 | newValue = {};
|
479 | }
|
480 | }
|
481 | var _loop_1 = function (key) {
|
482 | var valueKey = key, newValueKey = key, propertyName = key;
|
483 | if (!this_1.options.ignoreDecorators && targetType) {
|
484 | if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {
|
485 | var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadataByCustomName(targetType, key);
|
486 | if (exposeMetadata) {
|
487 | propertyName = exposeMetadata.propertyName;
|
488 | newValueKey = exposeMetadata.propertyName;
|
489 | }
|
490 | }
|
491 | else if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN || this_1.transformationType === TransformationType.CLASS_TO_CLASS) {
|
492 | var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(targetType, key);
|
493 | if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {
|
494 | newValueKey = exposeMetadata.options.name;
|
495 | }
|
496 | }
|
497 | }
|
498 |
|
499 | var subValue = undefined;
|
500 | if (value instanceof Map) {
|
501 | subValue = value.get(valueKey);
|
502 | }
|
503 | else if (value[valueKey] instanceof Function) {
|
504 | subValue = value[valueKey]();
|
505 | }
|
506 | else {
|
507 | subValue = value[valueKey];
|
508 | }
|
509 |
|
510 | var type = undefined, isSubValueMap = subValue instanceof Map;
|
511 | if (targetType && isMap) {
|
512 | type = targetType;
|
513 | }
|
514 | else if (targetType) {
|
515 | var metadata_1 = storage_1.defaultMetadataStorage.findTypeMetadata(targetType, propertyName);
|
516 | if (metadata_1) {
|
517 | var options = { newObject: newValue, object: value, property: propertyName };
|
518 | var newType = metadata_1.typeFunction ? metadata_1.typeFunction(options) : metadata_1.reflectedType;
|
519 | if (metadata_1.options && metadata_1.options.discriminator && metadata_1.options.discriminator.property && metadata_1.options.discriminator.subTypes) {
|
520 | if (!(value[valueKey] instanceof Array)) {
|
521 | if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {
|
522 | type = metadata_1.options.discriminator.subTypes.find(function (subType) {
|
523 | if (subValue && metadata_1.options.discriminator.property in subValue) {
|
524 | return subType.name === subValue[metadata_1.options.discriminator.property];
|
525 | }
|
526 | });
|
527 | type === undefined ? type = newType : type = type.value;
|
528 | if (!metadata_1.options.keepDiscriminatorProperty) {
|
529 | if (subValue && metadata_1.options.discriminator.property in subValue) {
|
530 | delete subValue[metadata_1.options.discriminator.property];
|
531 | }
|
532 | }
|
533 | }
|
534 | if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {
|
535 | type = subValue.constructor;
|
536 | }
|
537 | if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {
|
538 | subValue[metadata_1.options.discriminator.property] = metadata_1.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;
|
539 | }
|
540 | }
|
541 | else {
|
542 | type = metadata_1;
|
543 | }
|
544 | }
|
545 | else {
|
546 | type = newType;
|
547 | }
|
548 | isSubValueMap = isSubValueMap || metadata_1.reflectedType === Map;
|
549 | }
|
550 | else if (this_1.options.targetMaps) {
|
551 | this_1.options.targetMaps
|
552 | .filter(function (map) { return map.target === targetType && !!map.properties[propertyName]; })
|
553 | .forEach(function (map) { return type = map.properties[propertyName]; });
|
554 | }
|
555 | else if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {
|
556 |
|
557 |
|
558 | var reflectedType = Reflect.getMetadata("design:type", targetType.prototype, propertyName);
|
559 | if (reflectedType) {
|
560 | type = reflectedType;
|
561 | }
|
562 | }
|
563 | }
|
564 |
|
565 | var arrayType_1 = Array.isArray(value[valueKey]) ? this_1.getReflectedType(targetType, propertyName) : undefined;
|
566 |
|
567 | var subSource = source ? source[valueKey] : undefined;
|
568 |
|
569 |
|
570 |
|
571 |
|
572 |
|
573 | if (newValue.constructor.prototype) {
|
574 | var descriptor = Object.getOwnPropertyDescriptor(newValue.constructor.prototype, newValueKey);
|
575 | if ((this_1.transformationType === TransformationType.PLAIN_TO_CLASS || this_1.transformationType === TransformationType.CLASS_TO_CLASS)
|
576 | && ((descriptor && !descriptor.writable) || newValue[newValueKey] instanceof Function))
|
577 | return "continue";
|
578 | }
|
579 | if (!this_1.options.enableCircularCheck || !this_1.isCircular(subValue)) {
|
580 | var transformKey = this_1.transformationType === TransformationType.PLAIN_TO_CLASS ? newValueKey : key;
|
581 | var finalValue = void 0;
|
582 | if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {
|
583 |
|
584 | finalValue = value[transformKey];
|
585 |
|
586 | finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);
|
587 |
|
588 | finalValue = (value[transformKey] === finalValue) ? subValue : finalValue;
|
589 |
|
590 | finalValue = this_1.transform(subSource, finalValue, type, arrayType_1, isSubValueMap, level + 1);
|
591 | }
|
592 | else {
|
593 | finalValue = this_1.transform(subSource, subValue, type, arrayType_1, isSubValueMap, level + 1);
|
594 | finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);
|
595 | }
|
596 | if (newValue instanceof Map) {
|
597 | newValue.set(newValueKey, finalValue);
|
598 | }
|
599 | else {
|
600 | newValue[newValueKey] = finalValue;
|
601 | }
|
602 | }
|
603 | else if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {
|
604 | var finalValue = subValue;
|
605 | finalValue = this_1.applyCustomTransformations(finalValue, targetType, key, value, this_1.transformationType);
|
606 | if (newValue instanceof Map) {
|
607 | newValue.set(newValueKey, finalValue);
|
608 | }
|
609 | else {
|
610 | newValue[newValueKey] = finalValue;
|
611 | }
|
612 | }
|
613 | };
|
614 | var this_1 = this;
|
615 |
|
616 | for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
|
617 | var key = keys_1[_i];
|
618 | _loop_1(key);
|
619 | }
|
620 | if (this.options.enableCircularCheck) {
|
621 | this.recursionStack.delete(value);
|
622 | }
|
623 | return newValue;
|
624 | }
|
625 | else {
|
626 | return value;
|
627 | }
|
628 | };
|
629 | TransformOperationExecutor.prototype.applyCustomTransformations = function (value, target, key, obj, transformationType) {
|
630 | var _this = this;
|
631 | var metadatas = storage_1.defaultMetadataStorage.findTransformMetadatas(target, key, this.transformationType);
|
632 |
|
633 | if (this.options.version !== undefined) {
|
634 | metadatas = metadatas.filter(function (metadata) {
|
635 | if (!metadata.options)
|
636 | return true;
|
637 | return _this.checkVersion(metadata.options.since, metadata.options.until);
|
638 | });
|
639 | }
|
640 |
|
641 | if (this.options.groups && this.options.groups.length) {
|
642 | metadatas = metadatas.filter(function (metadata) {
|
643 | if (!metadata.options)
|
644 | return true;
|
645 | return _this.checkGroups(metadata.options.groups);
|
646 | });
|
647 | }
|
648 | else {
|
649 | metadatas = metadatas.filter(function (metadata) {
|
650 | return !metadata.options || !metadata.options.groups || !metadata.options.groups.length;
|
651 | });
|
652 | }
|
653 | metadatas.forEach(function (metadata) {
|
654 | value = metadata.transformFn(value, obj, transformationType);
|
655 | });
|
656 | return value;
|
657 | };
|
658 |
|
659 | TransformOperationExecutor.prototype.isCircular = function (object) {
|
660 | return this.recursionStack.has(object);
|
661 | };
|
662 | TransformOperationExecutor.prototype.getReflectedType = function (target, propertyName) {
|
663 | if (!target)
|
664 | return undefined;
|
665 | var meta = storage_1.defaultMetadataStorage.findTypeMetadata(target, propertyName);
|
666 | return meta ? meta.reflectedType : undefined;
|
667 | };
|
668 | TransformOperationExecutor.prototype.getKeys = function (target, object) {
|
669 | var _this = this;
|
670 |
|
671 | var strategy = storage_1.defaultMetadataStorage.getStrategy(target);
|
672 | if (strategy === "none")
|
673 | strategy = this.options.strategy || "exposeAll";
|
674 |
|
675 | var keys = [];
|
676 | if (strategy === "exposeAll") {
|
677 | if (object instanceof Map) {
|
678 | keys = Array.from(object.keys());
|
679 | }
|
680 | else {
|
681 | keys = Object.keys(object);
|
682 | }
|
683 | }
|
684 | if (!this.options.ignoreDecorators && target) {
|
685 |
|
686 | var exposedProperties = storage_1.defaultMetadataStorage.getExposedProperties(target, this.transformationType);
|
687 | if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {
|
688 | exposedProperties = exposedProperties.map(function (key) {
|
689 | var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
|
690 | if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {
|
691 | return exposeMetadata.options.name;
|
692 | }
|
693 | return key;
|
694 | });
|
695 | }
|
696 | if (this.options.excludeExtraneousValues) {
|
697 | keys = exposedProperties;
|
698 | }
|
699 | else {
|
700 | keys = keys.concat(exposedProperties);
|
701 | }
|
702 |
|
703 | var excludedProperties_1 = storage_1.defaultMetadataStorage.getExcludedProperties(target, this.transformationType);
|
704 | if (excludedProperties_1.length > 0) {
|
705 | keys = keys.filter(function (key) {
|
706 | return excludedProperties_1.indexOf(key) === -1;
|
707 | });
|
708 | }
|
709 |
|
710 | if (this.options.version !== undefined) {
|
711 | keys = keys.filter(function (key) {
|
712 | var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
|
713 | if (!exposeMetadata || !exposeMetadata.options)
|
714 | return true;
|
715 | return _this.checkVersion(exposeMetadata.options.since, exposeMetadata.options.until);
|
716 | });
|
717 | }
|
718 |
|
719 | if (this.options.groups && this.options.groups.length) {
|
720 | keys = keys.filter(function (key) {
|
721 | var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
|
722 | if (!exposeMetadata || !exposeMetadata.options)
|
723 | return true;
|
724 | return _this.checkGroups(exposeMetadata.options.groups);
|
725 | });
|
726 | }
|
727 | else {
|
728 | keys = keys.filter(function (key) {
|
729 | var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
|
730 | return !exposeMetadata || !exposeMetadata.options || !exposeMetadata.options.groups || !exposeMetadata.options.groups.length;
|
731 | });
|
732 | }
|
733 | }
|
734 |
|
735 | if (this.options.excludePrefixes && this.options.excludePrefixes.length) {
|
736 | keys = keys.filter(function (key) { return _this.options.excludePrefixes.every(function (prefix) {
|
737 | return key.substr(0, prefix.length) !== prefix;
|
738 | }); });
|
739 | }
|
740 |
|
741 | keys = keys.filter(function (key, index, self) {
|
742 | return self.indexOf(key) === index;
|
743 | });
|
744 | return keys;
|
745 | };
|
746 | TransformOperationExecutor.prototype.checkVersion = function (since, until) {
|
747 | var decision = true;
|
748 | if (decision && since)
|
749 | decision = this.options.version >= since;
|
750 | if (decision && until)
|
751 | decision = this.options.version < until;
|
752 | return decision;
|
753 | };
|
754 | TransformOperationExecutor.prototype.checkGroups = function (groups) {
|
755 | if (!groups)
|
756 | return true;
|
757 | return this.options.groups.some(function (optionGroup) { return groups.indexOf(optionGroup) !== -1; });
|
758 | };
|
759 | return TransformOperationExecutor;
|
760 | }());
|
761 | exports_9("TransformOperationExecutor", TransformOperationExecutor);
|
762 | }
|
763 | };
|
764 | });
|
765 | System.register("class-transformer/ClassTransformer", ["class-transformer/TransformOperationExecutor"], function (exports_10, context_10) {
|
766 | "use strict";
|
767 | var TransformOperationExecutor_2, ClassTransformer;
|
768 | var __moduleName = context_10 && context_10.id;
|
769 | return {
|
770 | setters: [
|
771 | function (TransformOperationExecutor_2_1) {
|
772 | TransformOperationExecutor_2 = TransformOperationExecutor_2_1;
|
773 | }
|
774 | ],
|
775 | execute: function () {
|
776 | ClassTransformer = (function () {
|
777 | function ClassTransformer() {
|
778 | }
|
779 | ClassTransformer.prototype.classToPlain = function (object, options) {
|
780 | var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_PLAIN, options || {});
|
781 | return executor.transform(undefined, object, undefined, undefined, undefined, undefined);
|
782 | };
|
783 | ClassTransformer.prototype.classToPlainFromExist = function (object, plainObject, options) {
|
784 | var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_PLAIN, options || {});
|
785 | return executor.transform(plainObject, object, undefined, undefined, undefined, undefined);
|
786 | };
|
787 | ClassTransformer.prototype.plainToClass = function (cls, plain, options) {
|
788 | var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.PLAIN_TO_CLASS, options || {});
|
789 | return executor.transform(undefined, plain, cls, undefined, undefined, undefined);
|
790 | };
|
791 | ClassTransformer.prototype.plainToClassFromExist = function (clsObject, plain, options) {
|
792 | var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.PLAIN_TO_CLASS, options || {});
|
793 | return executor.transform(clsObject, plain, undefined, undefined, undefined, undefined);
|
794 | };
|
795 | ClassTransformer.prototype.classToClass = function (object, options) {
|
796 | var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_CLASS, options || {});
|
797 | return executor.transform(undefined, object, undefined, undefined, undefined, undefined);
|
798 | };
|
799 | ClassTransformer.prototype.classToClassFromExist = function (object, fromObject, options) {
|
800 | var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_CLASS, options || {});
|
801 | return executor.transform(fromObject, object, undefined, undefined, undefined, undefined);
|
802 | };
|
803 | ClassTransformer.prototype.serialize = function (object, options) {
|
804 | return JSON.stringify(this.classToPlain(object, options));
|
805 | };
|
806 | |
807 |
|
808 |
|
809 | ClassTransformer.prototype.deserialize = function (cls, json, options) {
|
810 | var jsonObject = JSON.parse(json);
|
811 | return this.plainToClass(cls, jsonObject, options);
|
812 | };
|
813 | |
814 |
|
815 |
|
816 | ClassTransformer.prototype.deserializeArray = function (cls, json, options) {
|
817 | var jsonObject = JSON.parse(json);
|
818 | return this.plainToClass(cls, jsonObject, options);
|
819 | };
|
820 | return ClassTransformer;
|
821 | }());
|
822 | exports_10("ClassTransformer", ClassTransformer);
|
823 | }
|
824 | };
|
825 | });
|
826 | System.register("class-transformer/decorators", ["class-transformer/ClassTransformer", "class-transformer/storage", "class-transformer/metadata/TypeMetadata", "class-transformer/metadata/ExposeMetadata", "class-transformer/metadata/ExcludeMetadata", "class-transformer/metadata/TransformMetadata"], function (exports_11, context_11) {
|
827 | "use strict";
|
828 | var ClassTransformer_1, storage_2, TypeMetadata_1, ExposeMetadata_1, ExcludeMetadata_1, TransformMetadata_1;
|
829 | var __moduleName = context_11 && context_11.id;
|
830 | |
831 |
|
832 |
|
833 | function Transform(transformFn, options) {
|
834 | return function (target, key) {
|
835 | var metadata = new TransformMetadata_1.TransformMetadata(target.constructor, key, transformFn, options);
|
836 | storage_2.defaultMetadataStorage.addTransformMetadata(metadata);
|
837 | };
|
838 | }
|
839 | exports_11("Transform", Transform);
|
840 | |
841 |
|
842 |
|
843 |
|
844 | function Type(typeFunction, options) {
|
845 | return function (target, key) {
|
846 | var type = Reflect.getMetadata("design:type", target, key);
|
847 | var metadata = new TypeMetadata_1.TypeMetadata(target.constructor, key, type, typeFunction, options);
|
848 | storage_2.defaultMetadataStorage.addTypeMetadata(metadata);
|
849 | };
|
850 | }
|
851 | exports_11("Type", Type);
|
852 | |
853 |
|
854 |
|
855 |
|
856 |
|
857 | function Expose(options) {
|
858 | return function (object, propertyName) {
|
859 | var metadata = new ExposeMetadata_1.ExposeMetadata(object instanceof Function ? object : object.constructor, propertyName, options || {});
|
860 | storage_2.defaultMetadataStorage.addExposeMetadata(metadata);
|
861 | };
|
862 | }
|
863 | exports_11("Expose", Expose);
|
864 | |
865 |
|
866 |
|
867 |
|
868 |
|
869 | function Exclude(options) {
|
870 | return function (object, propertyName) {
|
871 | var metadata = new ExcludeMetadata_1.ExcludeMetadata(object instanceof Function ? object : object.constructor, propertyName, options || {});
|
872 | storage_2.defaultMetadataStorage.addExcludeMetadata(metadata);
|
873 | };
|
874 | }
|
875 | exports_11("Exclude", Exclude);
|
876 | |
877 |
|
878 |
|
879 | function TransformClassToPlain(params) {
|
880 | return function (target, propertyKey, descriptor) {
|
881 | var classTransformer = new ClassTransformer_1.ClassTransformer();
|
882 | var originalMethod = descriptor.value;
|
883 | descriptor.value = function () {
|
884 | var args = [];
|
885 | for (var _i = 0; _i < arguments.length; _i++) {
|
886 | args[_i] = arguments[_i];
|
887 | }
|
888 | var result = originalMethod.apply(this, args);
|
889 | var isPromise = !!result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function";
|
890 | return isPromise ? result.then(function (data) { return classTransformer.classToPlain(data, params); }) : classTransformer.classToPlain(result, params);
|
891 | };
|
892 | };
|
893 | }
|
894 | exports_11("TransformClassToPlain", TransformClassToPlain);
|
895 | |
896 |
|
897 |
|
898 | function TransformClassToClass(params) {
|
899 | return function (target, propertyKey, descriptor) {
|
900 | var classTransformer = new ClassTransformer_1.ClassTransformer();
|
901 | var originalMethod = descriptor.value;
|
902 | descriptor.value = function () {
|
903 | var args = [];
|
904 | for (var _i = 0; _i < arguments.length; _i++) {
|
905 | args[_i] = arguments[_i];
|
906 | }
|
907 | var result = originalMethod.apply(this, args);
|
908 | var isPromise = !!result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function";
|
909 | return isPromise ? result.then(function (data) { return classTransformer.classToClass(data, params); }) : classTransformer.classToClass(result, params);
|
910 | };
|
911 | };
|
912 | }
|
913 | exports_11("TransformClassToClass", TransformClassToClass);
|
914 | |
915 |
|
916 |
|
917 | function TransformPlainToClass(classType, params) {
|
918 | return function (target, propertyKey, descriptor) {
|
919 | var classTransformer = new ClassTransformer_1.ClassTransformer();
|
920 | var originalMethod = descriptor.value;
|
921 | descriptor.value = function () {
|
922 | var args = [];
|
923 | for (var _i = 0; _i < arguments.length; _i++) {
|
924 | args[_i] = arguments[_i];
|
925 | }
|
926 | var result = originalMethod.apply(this, args);
|
927 | var isPromise = !!result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function";
|
928 | return isPromise ? result.then(function (data) { return classTransformer.plainToClass(classType, data, params); }) : classTransformer.plainToClass(classType, result, params);
|
929 | };
|
930 | };
|
931 | }
|
932 | exports_11("TransformPlainToClass", TransformPlainToClass);
|
933 | return {
|
934 | setters: [
|
935 | function (ClassTransformer_1_1) {
|
936 | ClassTransformer_1 = ClassTransformer_1_1;
|
937 | },
|
938 | function (storage_2_1) {
|
939 | storage_2 = storage_2_1;
|
940 | },
|
941 | function (TypeMetadata_1_1) {
|
942 | TypeMetadata_1 = TypeMetadata_1_1;
|
943 | },
|
944 | function (ExposeMetadata_1_1) {
|
945 | ExposeMetadata_1 = ExposeMetadata_1_1;
|
946 | },
|
947 | function (ExcludeMetadata_1_1) {
|
948 | ExcludeMetadata_1 = ExcludeMetadata_1_1;
|
949 | },
|
950 | function (TransformMetadata_1_1) {
|
951 | TransformMetadata_1 = TransformMetadata_1_1;
|
952 | }
|
953 | ],
|
954 | execute: function () {
|
955 | }
|
956 | };
|
957 | });
|
958 | System.register("class-transformer/index", ["class-transformer/ClassTransformer", "class-transformer/decorators"], function (exports_12, context_12) {
|
959 | "use strict";
|
960 | var ClassTransformer_2, classTransformer, TransformationType;
|
961 | var __moduleName = context_12 && context_12.id;
|
962 | function classToPlain(object, options) {
|
963 | return classTransformer.classToPlain(object, options);
|
964 | }
|
965 | exports_12("classToPlain", classToPlain);
|
966 | function classToPlainFromExist(object, plainObject, options) {
|
967 | return classTransformer.classToPlainFromExist(object, plainObject, options);
|
968 | }
|
969 | exports_12("classToPlainFromExist", classToPlainFromExist);
|
970 | function plainToClass(cls, plain, options) {
|
971 | return classTransformer.plainToClass(cls, plain, options);
|
972 | }
|
973 | exports_12("plainToClass", plainToClass);
|
974 | function plainToClassFromExist(clsObject, plain, options) {
|
975 | return classTransformer.plainToClassFromExist(clsObject, plain, options);
|
976 | }
|
977 | exports_12("plainToClassFromExist", plainToClassFromExist);
|
978 | function classToClass(object, options) {
|
979 | return classTransformer.classToClass(object, options);
|
980 | }
|
981 | exports_12("classToClass", classToClass);
|
982 | function classToClassFromExist(object, fromObject, options) {
|
983 | return classTransformer.classToClassFromExist(object, fromObject, options);
|
984 | }
|
985 | exports_12("classToClassFromExist", classToClassFromExist);
|
986 | function serialize(object, options) {
|
987 | return classTransformer.serialize(object, options);
|
988 | }
|
989 | exports_12("serialize", serialize);
|
990 | |
991 |
|
992 |
|
993 | function deserialize(cls, json, options) {
|
994 | return classTransformer.deserialize(cls, json, options);
|
995 | }
|
996 | exports_12("deserialize", deserialize);
|
997 | |
998 |
|
999 |
|
1000 | function deserializeArray(cls, json, options) {
|
1001 | return classTransformer.deserializeArray(cls, json, options);
|
1002 | }
|
1003 | exports_12("deserializeArray", deserializeArray);
|
1004 | var exportedNames_1 = {
|
1005 | "classToPlain": true,
|
1006 | "classToPlainFromExist": true,
|
1007 | "plainToClass": true,
|
1008 | "plainToClassFromExist": true,
|
1009 | "classToClass": true,
|
1010 | "classToClassFromExist": true,
|
1011 | "serialize": true,
|
1012 | "deserialize": true,
|
1013 | "deserializeArray": true,
|
1014 | "TransformationType": true,
|
1015 | "ClassTransformer": true
|
1016 | };
|
1017 | function exportStar_1(m) {
|
1018 | var exports = {};
|
1019 | for (var n in m) {
|
1020 | if (n !== "default" && !exportedNames_1.hasOwnProperty(n)) exports[n] = m[n];
|
1021 | }
|
1022 | exports_12(exports);
|
1023 | }
|
1024 | return {
|
1025 | setters: [
|
1026 | function (ClassTransformer_2_1) {
|
1027 | ClassTransformer_2 = ClassTransformer_2_1;
|
1028 | exports_12({
|
1029 | "ClassTransformer": ClassTransformer_2_1["ClassTransformer"]
|
1030 | });
|
1031 | },
|
1032 | function (decorators_1_1) {
|
1033 | exportStar_1(decorators_1_1);
|
1034 | }
|
1035 | ],
|
1036 | execute: function () {
|
1037 | classTransformer = new ClassTransformer_2.ClassTransformer();
|
1038 | |
1039 |
|
1040 |
|
1041 | (function (TransformationType) {
|
1042 | TransformationType[TransformationType["PLAIN_TO_CLASS"] = 0] = "PLAIN_TO_CLASS";
|
1043 | TransformationType[TransformationType["CLASS_TO_PLAIN"] = 1] = "CLASS_TO_PLAIN";
|
1044 | TransformationType[TransformationType["CLASS_TO_CLASS"] = 2] = "CLASS_TO_CLASS";
|
1045 | })(TransformationType || (TransformationType = {}));
|
1046 | exports_12("TransformationType", TransformationType);
|
1047 | }
|
1048 | };
|
1049 | });
|
1050 | System.register("class-transformer", ["class-transformer/index"], function (exports_13, context_13) {
|
1051 | "use strict";
|
1052 | var __moduleName = context_13 && context_13.id;
|
1053 | function exportStar_2(m) {
|
1054 | var exports = {};
|
1055 | for (var n in m) {
|
1056 | if (n !== "default") exports[n] = m[n];
|
1057 | }
|
1058 | exports_13(exports);
|
1059 | }
|
1060 | return {
|
1061 | setters: [
|
1062 | function (index_1_1) {
|
1063 | exportStar_2(index_1_1);
|
1064 | }
|
1065 | ],
|
1066 | execute: function () {
|
1067 | }
|
1068 | };
|
1069 | });
|