@dipscope/type-manager 7.0.0-beta.0 → 7.0.0

package/dist/es2015/serializers/string-serializer.js

@@ -1,55 +1,55 @@
-import { isBoolean, isDate, isNull, isNumber, isObject, isString, isUndefined } from 'lodash';
-export class StringSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isString(x)) {
-            return x;
-        }
-        if (serializerContext.useImplicitConversion) {
-            return this.convert(x, serializerContext);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as string.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isString(x)) {
-            return x;
-        }
-        if (serializerContext.useImplicitConversion) {
-            return this.convert(x, serializerContext);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as string.`, x);
-        }
-        return undefined;
-    }
-    convert(x, serializerContext) {
-        if (isNumber(x) || isBoolean(x)) {
-            return String(x);
-        }
-        if (isDate(x)) {
-            return x.toISOString();
-        }
-        if (isObject(x)) {
-            return JSON.stringify(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot convert value to string.`, x);
-        }
-        return undefined;
-    }
-}
+import { isBoolean, isDate, isNull, isNumber, isObject, isString, isUndefined } from 'lodash';
+export class StringSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isString(x)) {
+            return x;
+        }
+        if (serializerContext.useImplicitConversion) {
+            return this.convert(x, serializerContext);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as string.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isString(x)) {
+            return x;
+        }
+        if (serializerContext.useImplicitConversion) {
+            return this.convert(x, serializerContext);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as string.`, x);
+        }
+        return undefined;
+    }
+    convert(x, serializerContext) {
+        if (isNumber(x) || isBoolean(x)) {
+            return String(x);
+        }
+        if (isDate(x)) {
+            return x.toISOString();
+        }
+        if (isObject(x)) {
+            return JSON.stringify(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot convert value to string.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=string-serializer.js.map

package/dist/es2015/serializers/type-serializer.js

@@ -1,121 +1,121 @@
-import { isNil, isNull, isObject, isUndefined } from 'lodash';
-import { TypeContext } from '../type-context';
-import { TypeContextEntry } from '../type-context-entry';
-export class TypeSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isObject(x)) {
-            return serializerContext.defineReference(x, () => {
-                const type = x;
-                const typeSerializerContext = serializerContext.polymorphic
-                    ? serializerContext.definePolymorphicSerializerContext(x.constructor)
-                    : serializerContext;
-                const propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: typeSerializerContext.jsonPathKey
-                });
-                const typeMetadata = typeSerializerContext.typeMetadata;
-                const object = {};
-                for (const propertyMetadata of typeMetadata.sortedPropertyMetadatas) {
-                    if (propertyMetadata.serializationConfigured && !propertyMetadata.serializable) {
-                        continue;
-                    }
-                    const serializedPropertyName = propertyMetadata.serializedPropertyName;
-                    const deserializedPropertyName = propertyMetadata.deserializedPropertyName;
-                    const propertyValue = type[deserializedPropertyName];
-                    propertySerializerContext.hasJsonPathKey(serializedPropertyName);
-                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
-                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
-                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
-                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
-                    propertySerializerContext.hasReferenceValueSetter(v => {
-                        const declaringObject = propertySerializerContext.referenceMap.get(type);
-                        if (!isNil(declaringObject)) {
-                            declaringObject[serializedPropertyName] = v;
-                        }
-                    });
-                    const value = propertySerializerContext.serialize(propertyValue);
-                    object[serializedPropertyName] = value;
-                }
-                if (typeSerializerContext.preserveDiscriminator) {
-                    object[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
-                }
-                else if (object.hasOwnProperty(typeSerializerContext.discriminator)) {
-                    delete object[typeSerializerContext.discriminator];
-                }
-                return object;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as type.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isObject(x)) {
-            return serializerContext.restoreReference(x, () => {
-                const object = x;
-                const typeSerializerContext = serializerContext.polymorphic
-                    ? serializerContext.definePolymorphicSerializerContext(x)
-                    : serializerContext;
-                const propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: typeSerializerContext.jsonPath
-                });
-                const typeMetadata = typeSerializerContext.typeMetadata;
-                const typeContext = new TypeContext(typeMetadata);
-                for (const propertyMetadata of typeMetadata.sortedPropertyMetadatas) {
-                    if (propertyMetadata.serializationConfigured && !propertyMetadata.deserializable) {
-                        continue;
-                    }
-                    const serializedPropertyName = propertyMetadata.serializedPropertyName;
-                    const deserializedPropertyName = propertyMetadata.deserializedPropertyName;
-                    const propertyValue = object[serializedPropertyName];
-                    propertySerializerContext.hasJsonPathKey(deserializedPropertyName);
-                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
-                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
-                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
-                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
-                    propertySerializerContext.hasReferenceValueSetter(v => {
-                        const declaringType = propertySerializerContext.referenceMap.get(object);
-                        if (!isNil(declaringType)) {
-                            declaringType[deserializedPropertyName] = v;
-                        }
-                    });
-                    const value = propertySerializerContext.deserialize(propertyValue);
-                    typeContext.set(deserializedPropertyName, new TypeContextEntry(deserializedPropertyName, value, propertyMetadata));
-                    typeContext.set(serializedPropertyName, new TypeContextEntry(serializedPropertyName, value, propertyMetadata));
-                }
-                for (const propertyName in object) {
-                    if (object.hasOwnProperty(propertyName)) {
-                        typeContext.set(propertyName, new TypeContextEntry(propertyName, object[propertyName]));
-                    }
-                }
-                const factory = typeSerializerContext.factory;
-                const injector = typeSerializerContext.injector;
-                const type = factory.build(typeContext, injector);
-                if (typeSerializerContext.preserveDiscriminator) {
-                    type[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
-                }
-                else if (type.hasOwnProperty(typeSerializerContext.discriminator)) {
-                    delete type[typeSerializerContext.discriminator];
-                }
-                return type;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as type.`, x);
-        }
-        return undefined;
-    }
-}
+import { isNil, isNull, isObject, isUndefined } from 'lodash';
+import { TypeContext } from '../type-context';
+import { TypeContextEntry } from '../type-context-entry';
+export class TypeSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isObject(x)) {
+            return serializerContext.defineReference(x, () => {
+                const type = x;
+                const typeSerializerContext = serializerContext.polymorphic
+                    ? serializerContext.definePolymorphicSerializerContext(x.constructor)
+                    : serializerContext;
+                const propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: typeSerializerContext.jsonPathKey
+                });
+                const typeMetadata = typeSerializerContext.typeMetadata;
+                const object = {};
+                for (const propertyMetadata of typeMetadata.sortedPropertyMetadatas) {
+                    if (propertyMetadata.serializationConfigured && !propertyMetadata.serializable) {
+                        continue;
+                    }
+                    const serializedPropertyName = propertyMetadata.serializedPropertyName;
+                    const deserializedPropertyName = propertyMetadata.deserializedPropertyName;
+                    const propertyValue = type[deserializedPropertyName];
+                    propertySerializerContext.hasJsonPathKey(serializedPropertyName);
+                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
+                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
+                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
+                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
+                    propertySerializerContext.hasReferenceValueSetter(v => {
+                        const declaringObject = propertySerializerContext.referenceMap.get(type);
+                        if (!isNil(declaringObject)) {
+                            declaringObject[serializedPropertyName] = v;
+                        }
+                    });
+                    const value = propertySerializerContext.serialize(propertyValue);
+                    object[serializedPropertyName] = value;
+                }
+                if (typeSerializerContext.preserveDiscriminator) {
+                    object[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
+                }
+                else if (object.hasOwnProperty(typeSerializerContext.discriminator)) {
+                    delete object[typeSerializerContext.discriminator];
+                }
+                return object;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as type.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isObject(x)) {
+            return serializerContext.restoreReference(x, () => {
+                const object = x;
+                const typeSerializerContext = serializerContext.polymorphic
+                    ? serializerContext.definePolymorphicSerializerContext(x)
+                    : serializerContext;
+                const propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: typeSerializerContext.jsonPath
+                });
+                const typeMetadata = typeSerializerContext.typeMetadata;
+                const typeContext = new TypeContext(typeMetadata);
+                for (const propertyMetadata of typeMetadata.sortedPropertyMetadatas) {
+                    if (propertyMetadata.serializationConfigured && !propertyMetadata.deserializable) {
+                        continue;
+                    }
+                    const serializedPropertyName = propertyMetadata.serializedPropertyName;
+                    const deserializedPropertyName = propertyMetadata.deserializedPropertyName;
+                    const propertyValue = object[serializedPropertyName];
+                    propertySerializerContext.hasJsonPathKey(deserializedPropertyName);
+                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
+                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
+                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
+                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
+                    propertySerializerContext.hasReferenceValueSetter(v => {
+                        const declaringType = propertySerializerContext.referenceMap.get(object);
+                        if (!isNil(declaringType)) {
+                            declaringType[deserializedPropertyName] = v;
+                        }
+                    });
+                    const value = propertySerializerContext.deserialize(propertyValue);
+                    typeContext.set(deserializedPropertyName, new TypeContextEntry(deserializedPropertyName, value, propertyMetadata));
+                    typeContext.set(serializedPropertyName, new TypeContextEntry(serializedPropertyName, value, propertyMetadata));
+                }
+                for (const propertyName in object) {
+                    if (object.hasOwnProperty(propertyName)) {
+                        typeContext.set(propertyName, new TypeContextEntry(propertyName, object[propertyName]));
+                    }
+                }
+                const factory = typeSerializerContext.factory;
+                const injector = typeSerializerContext.injector;
+                const type = factory.build(typeContext, injector);
+                if (typeSerializerContext.preserveDiscriminator) {
+                    type[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
+                }
+                else if (type.hasOwnProperty(typeSerializerContext.discriminator)) {
+                    delete type[typeSerializerContext.discriminator];
+                }
+                return type;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as type.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=type-serializer.js.map

package/dist/es2015/serializers/uint-16-array-serializer.js

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint16Array } from '../functions/is-uint-16-array';
-export class Uint16ArraySerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint16Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 16 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint16Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 16 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint16Array } from '../functions/is-uint-16-array';
+export class Uint16ArraySerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint16Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 16 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint16Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 16 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=uint-16-array-serializer.js.map

package/dist/es2015/serializers/uint-32-array-serializer.js

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint32Array } from '../functions/is-uint-32-array';
-export class Uint32ArraySerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint32Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 32 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint32Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 32 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint32Array } from '../functions/is-uint-32-array';
+export class Uint32ArraySerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint32Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 32 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint32Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 32 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=uint-32-array-serializer.js.map

package/dist/es2015/serializers/uint-8-array-serializer.js

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint8Array } from '../functions/is-uint-8-array';
-export class Uint8ArraySerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint8Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 8 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint8Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 8 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint8Array } from '../functions/is-uint-8-array';
+export class Uint8ArraySerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint8Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 8 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint8Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 8 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=uint-8-array-serializer.js.map

package/dist/es2015/serializers/uint-8-clamped-array-serializer.js

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint8ClampedArray } from '../functions/is-uint-8-clamped-array';
-export class Uint8ClampedArraySerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint8ClampedArray(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 8 clamped array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint8ClampedArray.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 8 clamped array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint8ClampedArray } from '../functions/is-uint-8-clamped-array';
+export class Uint8ClampedArraySerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint8ClampedArray(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as uint 8 clamped array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint8ClampedArray.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as uint 8 clamped array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=uint-8-clamped-array-serializer.js.map