@cornerstonejs/core 2.0.0-beta.28 → 2.0.0-beta.29

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -1,6 +1,7 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 import cache from '../../cache/cache';
+import { getConstructorFromType } from '../../utilities/getBufferConfiguration';
 function vtkStreamingOpenGLTexture(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLTexture');
     model.updatedFrames = [];
@@ -71,13 +72,19 @@ function vtkStreamingOpenGLTexture(publicAPI, model) {
     function updateDynamicVolumeTexture() {
         const volume = cache.getVolume(model.volumeId);
         const imageIds = volume.getCurrentTimePointImageIds();
+        let constructor;
         for (let i = 0; i < imageIds.length; i++) {
             const imageId = imageIds[i];
             const image = cache.getImage(imageId);
+            let data;
             if (!image) {
-                continue;
+                constructor = getConstructorFromType(volume.dataType, true);
+                data = new constructor(model.width * model.height);
+            }
+            else {
+                data = image.voxelManager.getScalarData();
+                constructor = data.constructor;
             }
-            const data = image.voxelManager.getScalarData();
             const gl = model.context;
             const dataType = data.constructor.name;
             const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);

package/dist/esm/cache/classes/BaseStreamingImageVolume.d.ts

@@ -9,7 +9,6 @@ export default class BaseStreamingImageVolume extends ImageVolume implements IIm
     protected cachedFrames: any[];
     protected reRenderTarget: number;
     protected reRenderFraction: number;
-    dataType: PixelDataTypedArrayString;
     loadStatus: {
         loaded: boolean;
         loading: boolean;

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -36,10 +36,12 @@ export default class BaseStreamingImageVolume extends ImageVolume {
             const { imageIds, loadStatus, numFrames } = this;
             const { transferSyntaxUID } = metaData.get('transferSyntax', imageIds[0]) || {};
             const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, this.volumeId, transferSyntaxUID, 'volume');
-            this.imagesLoader = imageRetrieveConfiguration
-                ? (imageRetrieveConfiguration.create ||
-                    ProgressiveRetrieveImages.createProgressive)(imageRetrieveConfiguration)
-                : this;
+            this.imagesLoader = this.isDynamicVolume()
+                ? this
+                : imageRetrieveConfiguration
+                    ? (imageRetrieveConfiguration.create ||
+                        ProgressiveRetrieveImages.createProgressive)(imageRetrieveConfiguration)
+                    : this;
             if (loadStatus.loading === true) {
                 return;
             }

package/dist/esm/init.js

@@ -1,3 +1,4 @@
+console.debug("core: link: init: 3DA675F2-86A1-41A1-9E15-A7019E085C0F");
 import { getRenderingEngines } from './RenderingEngine/getRenderingEngine';
 let csRenderInitialized = false;
 import deepMerge from './utilities/deepMerge';

package/dist/esm/loaders/configuration/interleavedRetrieve.js

@@ -28,46 +28,5 @@ const interleavedRetrieveConfiguration = [
         priority: 6,
         nearbyFrames,
     },
-    {
-        id: 'halfThumb',
-        decimate: 4,
-        offset: 1,
-        priority: 7,
-        requestType: RequestType.Thumbnail,
-        retrieveType: 'multipleFast',
-        nearbyFrames,
-    },
-    {
-        id: 'quarterFull',
-        decimate: 4,
-        offset: 2,
-        priority: 8,
-        requestType: RequestType.Thumbnail,
-        retrieveType: 'multipleFinal',
-    },
-    {
-        id: 'halfFull',
-        decimate: 4,
-        offset: 0,
-        priority: 9,
-        requestType: RequestType.Thumbnail,
-        retrieveType: 'multipleFinal',
-    },
-    {
-        id: 'threeQuarterFull',
-        decimate: 4,
-        offset: 1,
-        priority: 10,
-        requestType: RequestType.Thumbnail,
-        retrieveType: 'multipleFinal',
-    },
-    {
-        id: 'finalFull',
-        decimate: 4,
-        offset: 3,
-        priority: 11,
-        requestType: RequestType.Thumbnail,
-        retrieveType: 'multipleFinal',
-    },
 ];
 export default interleavedRetrieveConfiguration;

package/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.js

@@ -6,7 +6,8 @@ function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
     }
     const { imageIds } = options;
     const { splittingTag, imageIdGroups } = splitImageIdsBy4DTags(imageIds);
-    const volumeProps = generateVolumePropsFromImageIds(imageIdGroups[0], volumeId);
+    const middleIndex = Math.floor(imageIdGroups.length / 2);
+    const volumeProps = generateVolumePropsFromImageIds(imageIdGroups[middleIndex], volumeId);
     const { metadata: volumeMetadata, dimensions, spacing, direction, sizeInBytes, origin, numberOfComponents, dataType, } = volumeProps;
     const scanAxisNormal = direction.slice(6, 9);
     const sortedImageIdGroups = imageIdGroups.map((imageIds) => {

package/dist/esm/loaders/volumeLoader.js

@@ -68,7 +68,9 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
         volumeId = uuidv4();
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
-    const referencedImageIds = referencedVolume.imageIds ?? [];
+    const referencedImageIds = referencedVolume.isDynamicVolume()
+        ? referencedVolume.getCurrentTimePointImageIds()
+        : referencedVolume.imageIds ?? [];
     const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBuffer: options.targetBuffer,
     });

package/dist/esm/utilities/VoxelManager.js

@@ -21,7 +21,7 @@ export default class VoxelManager {
         this.setAtIJK = (i, j, k, v) => {
             const index = this.toIndex([i, j, k]);
             const changed = this._set(index, v);
-            if (changed) {
+            if (changed !== false) {
                 this.modifiedSlices.add(k);
                 VoxelManager.addBounds(this.boundsIJK, [i, j, k]);
             }
@@ -34,7 +34,7 @@ export default class VoxelManager {
         this.getAtIndex = (index) => this._get(index);
         this.setAtIndex = (index, v) => {
             const changed = this._set(index, v);
-            if (changed) {
+            if (changed !== false) {
                 const pointIJK = this.toIJK(index);
                 this.modifiedSlices.add(pointIJK[2]);
                 VoxelManager.addBounds(this.boundsIJK, pointIJK);
@@ -519,33 +519,36 @@ export default class VoxelManager {
                 numberOfComponents,
             });
         });
-        const voxelManager = new VoxelManager(dimensions, (index) => voxelGroups[timePoint]._get(index), (index, v) => voxelGroups[timePoint]._set(index, v));
+        const voxelManager = new VoxelManager(dimensions, (index) => voxelGroups[timePoint - 1]._get(index), (index, v) => voxelGroups[timePoint - 1]._set(index, v));
         voxelManager.numberOfComponents = numberOfComponents;
         voxelManager.getScalarDataLength = () => {
-            return voxelGroups[timePoint].getScalarDataLength();
+            return voxelGroups[timePoint - 1].getScalarDataLength();
         };
         voxelManager.getConstructor = () => {
-            return voxelGroups[timePoint].getConstructor();
+            return voxelGroups[timePoint - 1].getConstructor();
         };
         voxelManager.getRange = () => {
-            return voxelGroups[timePoint].getRange();
+            return voxelGroups[timePoint - 1].getRange();
         };
         voxelManager.getMiddleSliceData = () => {
-            return voxelGroups[timePoint].getMiddleSliceData();
+            return voxelGroups[timePoint - 1].getMiddleSliceData();
         };
         voxelManager.setTimePoint = (newTimePoint) => {
             timePoint = newTimePoint;
-            voxelManager._get = (index) => voxelGroups[timePoint]._get(index);
-            voxelManager._set = (index, v) => voxelGroups[timePoint]._set(index, v);
+            voxelManager._get = (index) => voxelGroups[timePoint - 1]._get(index);
+            voxelManager._set = (index, v) => voxelGroups[timePoint - 1]._set(index, v);
         };
         voxelManager.getAtIndexAndTimePoint = (index, tp) => {
-            return voxelGroups[tp]._get(index);
+            return voxelGroups[tp - 1]._get(index);
         };
         voxelManager.getTimePointScalarData = (tp) => {
-            return voxelGroups[tp].getCompleteScalarDataArray();
+            return voxelGroups[tp - 1].getCompleteScalarDataArray();
+        };
+        voxelManager.getTimePointScalarData = (tp) => {
+            return voxelGroups[tp - 1].getCompleteScalarDataArray();
         };
         voxelManager.getCurrentTimePointScalarData = () => {
-            return voxelGroups[timePoint].getCompleteScalarDataArray();
+            return voxelGroups[timePoint - 1].getCompleteScalarDataArray();
         };
         return voxelManager;
     }

package/dist/esm/utilities/deepClone.js

@@ -6,12 +6,7 @@ export function deepClone(obj) {
         return obj;
     }
     if (typeof structuredClone === 'function') {
-        try {
-            return structuredClone(obj);
-        }
-        catch (error) {
-            console.debug('structuredClone failed, falling back to custom implementation');
-        }
+        return obj;
     }
     if (Array.isArray(obj)) {
         return obj.map(deepClone);

package/dist/esm/utilities/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(obj1: unknown, obj2: unknown): boolean;

package/dist/esm/utilities/deepEqual.js

@@ -0,0 +1,15 @@
+export function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 == null || obj2 == null) {
+        return false;
+    }
+    try {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+    catch (error) {
+        console.debug('Error in JSON.stringify during deep comparison:', error);
+        return obj1 === obj2;
+    }
+}

package/dist/esm/utilities/getBufferConfiguration.d.ts

@@ -1,8 +1,9 @@
 import type { PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
+declare function getConstructorFromType(bufferType: PixelDataTypedArrayString, isVolumeBuffer: boolean): new (length: number) => PixelDataTypedArray;
 declare function getBufferConfiguration(targetBufferType: PixelDataTypedArrayString, length: number, options?: {
     isVolumeBuffer?: boolean;
 }): {
     numBytes: number;
     TypedArrayConstructor: new (length: number) => PixelDataTypedArray;
 };
-export { getBufferConfiguration };
+export { getBufferConfiguration, getConstructorFromType };

package/dist/esm/utilities/getBufferConfiguration.js

@@ -1,33 +1,32 @@
-function getBufferConfiguration(targetBufferType, length, options = {}) {
-    const { isVolumeBuffer = false } = options;
-    switch (targetBufferType) {
+function getConstructorFromType(bufferType, isVolumeBuffer) {
+    switch (bufferType) {
         case 'Float32Array':
-            return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+            return Float32Array;
         case 'Uint8Array':
-            return { numBytes: length, TypedArrayConstructor: Uint8Array };
+            return Uint8Array;
         case 'Uint16Array':
-            if (!isVolumeBuffer) {
-                return { numBytes: length * 2, TypedArrayConstructor: Uint16Array };
-            }
-            else {
-                console.warn('Uint16Array is not supported for volume rendering, switching back to Float32Array');
-                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
-            }
         case 'Int16Array':
             if (!isVolumeBuffer) {
-                return { numBytes: length * 2, TypedArrayConstructor: Int16Array };
+                return bufferType === 'Uint16Array' ? Uint16Array : Int16Array;
             }
             else {
-                console.warn('Int16Array is not supported for volume rendering, switching back to Float32Array');
-                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+                console.debug(`${bufferType} is not supported for volume rendering, switching back to Float32Array`);
+                return Float32Array;
             }
         default:
-            if (targetBufferType) {
+            if (bufferType) {
                 throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, or Int16Array');
             }
             else {
-                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+                return Float32Array;
             }
     }
 }
-export { getBufferConfiguration };
+function getBufferConfiguration(targetBufferType, length, options = {}) {
+    const { isVolumeBuffer = false } = options;
+    const TypedArrayConstructor = getConstructorFromType(targetBufferType, isVolumeBuffer);
+    const bytesPerElement = TypedArrayConstructor.BYTES_PER_ELEMENT;
+    const numBytes = length * bytesPerElement;
+    return { numBytes, TypedArrayConstructor };
+}
+export { getBufferConfiguration, getConstructorFromType };

package/dist/esm/utilities/getClosestImageId.js

@@ -6,10 +6,14 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     if (!imageVolume) {
         return;
     }
-    const { direction, imageIds } = imageVolume;
+    const { direction } = imageVolume;
+    let { imageIds } = imageVolume;
     if (!imageIds.length) {
         return;
     }
+    if ('getCurrentTimePointImageIds' in imageVolume) {
+        imageIds = imageVolume.getCurrentTimePointImageIds();
+    }
     const kVector = direction.slice(6, 9);
     const dotProducts = vec3.dot(kVector, viewPlaneNormal);
     if (Math.abs(dotProducts) < 1 - EPSILON) {

package/dist/esm/utilities/index.d.ts

@@ -73,6 +73,7 @@ import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
 import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
+import { deepEqual } from './deepEqual';
 import type { IViewport } from '../types/IViewport';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
@@ -80,4 +81,4 @@ import scaleArray from './scaleArray';
 import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
 import { deepClone } from './deepClone';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
-export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, };
+export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, };

package/dist/esm/utilities/index.js

@@ -73,6 +73,7 @@ import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
 import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
+import { deepEqual } from './deepEqual';
 import { _getViewportModality } from './getViewportModality';
 import cache from '../cache/cache';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
@@ -81,4 +82,4 @@ import scaleArray from './scaleArray';
 import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
 import { deepClone } from './deepClone';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
-export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, };
+export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.0.0-beta.28",
+  "version": "2.0.0-beta.29",
   "description": "",
   "main": "./dist/umd/index.js",
   "module": "./dist/esm/index.js",
@@ -85,5 +85,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f07f340e5b63d3afdda66bfe35c9cef729a5b69d"
+  "gitHead": "fd9316cac241522bc5c43d267e41c7a4e36bec96"
 }