@mindexec/cli 0.2.476 → 0.2.478

package/wwwroot/_content/MindExecution.Shared/js/mind-map-glow-shader.js

@@ -1,11 +1,11 @@
 // File: mind-map-glow-shader.js
 // [New] SDF-based glow shader - NO TEXTURES, pure GPU math
 // Memory usage: 0 MB (vs hundreds of MBs for per-node textures)
-(function () {
-    'use strict';
-
-    // Shared across all glow materials to avoid per-node time uniform updates.
-    const SHARED_TIME_UNIFORM = { value: 0.0 };
+(function () {
+    'use strict';
+
+    // Shared across all glow materials to avoid per-node time uniform updates.
+    const SHARED_TIME_UNIFORM = { value: 0.0 };
 
     // ▼▼▼ SDF Glow Shader (Aspect Ratio Corrected) ▼▼▼
     // Uses pixel-based coordinates for uniform glow thickness
@@ -68,40 +68,40 @@
             return min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - r;
         }
         
-        void main() {
-            vec2 p = (vUv - 0.5) * vScale;
-            vec2 boxSize = (vScale * 0.5) - glowPadding;
-            float dist = sdRoundedBox(p, boxSize, cornerRadius);
-
-            // Keep glow organic, but modulate intensity instead of distorting the edge.
-            float noiseFreq = 0.65;
-            float noiseSpeed = 0.045;
-            float rawNoise = snoise(vUv * noiseFreq + time * noiseSpeed);
-            float noiseMod = 1.0 + (rawNoise * 0.08);
-
-            float aa = max(fwidth(dist), 0.9);
-            float outsideDist = max(dist, 0.0);
-            float outerFade = 1.0 - smoothstep(0.0, glowPadding + aa * 2.0, outsideDist);
-            float innerFade = smoothstep(-aa * 2.0, aa * 2.0, dist);
-            float coreBoost = 1.0 - smoothstep(glowPadding * 0.22, glowPadding * 0.78, outsideDist);
-
-            float alpha = outerFade * innerFade;
-            alpha *= mix(0.62, 1.0, coreBoost);
-            alpha *= noiseMod;
-
-            // Corner glow naturally looks heavier; taper it a bit for a softer envelope.
-            vec2 q = abs(p) - boxSize;
-            float cornerAmount = 0.0;
-            if (q.x > 0.0 && q.y > 0.0) {
-                cornerAmount = smoothstep(0.0, glowPadding * 0.65, min(q.x, q.y));
-            }
-            float cornerFactor = 1.0 - cornerAmount * 0.35;
-            alpha *= cornerFactor;
-            alpha = clamp(alpha, 0.0, 1.0);
-
-            gl_FragColor = vec4(color, alpha * opacity); // No inversion needed now
-        }
-    `;
+        void main() {
+            vec2 p = (vUv - 0.5) * vScale;
+            vec2 boxSize = (vScale * 0.5) - glowPadding;
+            float dist = sdRoundedBox(p, boxSize, cornerRadius);
+
+            // Keep glow organic, but modulate intensity instead of distorting the edge.
+            float noiseFreq = 0.65;
+            float noiseSpeed = 0.045;
+            float rawNoise = snoise(vUv * noiseFreq + time * noiseSpeed);
+            float noiseMod = 1.0 + (rawNoise * 0.08);
+
+            float aa = max(fwidth(dist), 0.9);
+            float outsideDist = max(dist, 0.0);
+            float outerFade = 1.0 - smoothstep(0.0, glowPadding + aa * 2.0, outsideDist);
+            float innerFade = smoothstep(-aa * 2.0, aa * 2.0, dist);
+            float coreBoost = 1.0 - smoothstep(glowPadding * 0.22, glowPadding * 0.78, outsideDist);
+
+            float alpha = outerFade * innerFade;
+            alpha *= mix(0.62, 1.0, coreBoost);
+            alpha *= noiseMod;
+
+            // Corner glow naturally looks heavier; taper it a bit for a softer envelope.
+            vec2 q = abs(p) - boxSize;
+            float cornerAmount = 0.0;
+            if (q.x > 0.0 && q.y > 0.0) {
+                cornerAmount = smoothstep(0.0, glowPadding * 0.65, min(q.x, q.y));
+            }
+            float cornerFactor = 1.0 - cornerAmount * 0.35;
+            alpha *= cornerFactor;
+            alpha = clamp(alpha, 0.0, 1.0);
+
+            gl_FragColor = vec4(color, alpha * opacity); // No inversion needed now
+        }
+    `;
 
     /**
      * Create SDF glow material with pixel-based uniforms
@@ -122,22 +122,22 @@
             ? new THREE.Color(config.color)
             : config.color;
 
-        return new THREE.ShaderMaterial({
-            transparent: true,
-            depthWrite: false,
-            depthTest: true,
-            uniforms: {
+        return new THREE.ShaderMaterial({
+            transparent: true,
+            depthWrite: false,
+            depthTest: true,
+            uniforms: {
                 color: { value: colorValue },
                 opacity: { value: config.opacity },
-                meshScale: { value: new THREE.Vector2(config.meshScale[0], config.meshScale[1]) },
-                glowPadding: { value: config.glowPadding },
-                cornerRadius: { value: config.cornerRadius },
-                time: SHARED_TIME_UNIFORM // ★ Shared animation time uniform
-            },
-            vertexShader: GLOW_VERTEX_SHADER,
-            fragmentShader: GLOW_FRAGMENT_SHADER
-        });
-    }
+                meshScale: { value: new THREE.Vector2(config.meshScale[0], config.meshScale[1]) },
+                glowPadding: { value: config.glowPadding },
+                cornerRadius: { value: config.cornerRadius },
+                time: SHARED_TIME_UNIFORM // ★ Shared animation time uniform
+            },
+            vertexShader: GLOW_VERTEX_SHADER,
+            fragmentShader: GLOW_FRAGMENT_SHADER
+        });
+    }
 
     /**
      * Create or update glow mesh using SDF shader (pixel-based)
@@ -234,27 +234,27 @@
      * @param {THREE.Mesh} glowMesh - Glow mesh to update
      * @param {number} time - Current time in seconds
      */
-    function updateGlowTime(glowMesh, time) {
-        setTime(time);
-    }
-
-    /**
-     * Update shared time uniform for all glow meshes in O(1).
-     * @param {number} time - Current time in seconds
-     */
-    function setTime(time) {
-        SHARED_TIME_UNIFORM.value = time;
-    }
+    function updateGlowTime(glowMesh, time) {
+        setTime(time);
+    }
+
+    /**
+     * Update shared time uniform for all glow meshes in O(1).
+     * @param {number} time - Current time in seconds
+     */
+    function setTime(time) {
+        SHARED_TIME_UNIFORM.value = time;
+    }
 
     // Expose API globally
     window.MindMapGlowShader = {
         createSDFGlowMaterial,
-        createSDFGlowMesh,
-        updateGlowSelection,
-        updateGlowSize,
-        updateGlowTime, // Backward compatibility
-        setTime
-    };
+        createSDFGlowMesh,
+        updateGlowSelection,
+        updateGlowSize,
+        updateGlowTime, // Backward compatibility
+        setTime
+    };
 
     console.log('✅ mind-map-glow-shader.js loaded (SDF Glow - No Textures!)');
 })();

package/wwwroot/_content/MindExecution.Shared/js/mind-map-image-policy.js

@@ -1,218 +1,218 @@
-(function () {
-    'use strict';
-
-    const BUILD_ID = '20260819-image-original-resize-v2';
-
-    function normalizeContentType(nodeModel) {
-        return String(nodeModel?.contentType ?? nodeModel?.ContentType ?? '').trim().toLowerCase();
-    }
-
-    function getMetadata(nodeModel) {
-        return nodeModel?.metadata ?? nodeModel?.Metadata ?? {};
-    }
-
-    function getMetadataValue(metadata, ...keys) {
-        if (!metadata || typeof metadata !== 'object') return '';
-
-        for (const key of keys) {
-            const value = metadata[key];
-            if (value !== undefined && value !== null && String(value).trim()) {
-                return String(value).trim();
-            }
-        }
-
-        const wanted = new Set(keys.map(key => String(key).toLowerCase()));
-        for (const [key, value] of Object.entries(metadata)) {
-            if (wanted.has(String(key).toLowerCase())
-                && value !== undefined
-                && value !== null
-                && String(value).trim()) {
-                return String(value).trim();
-            }
-        }
-
-        return '';
-    }
-
-    function toPositiveNumber(value) {
-        const numeric = Number(value);
-        return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
-    }
-
-    function ratioFromPair(width, height) {
-        const numericWidth = toPositiveNumber(width);
-        const numericHeight = toPositiveNumber(height);
-        if (!(numericWidth > 0 && numericHeight > 0)) return 0;
-
-        const ratio = numericWidth / numericHeight;
-        return Number.isFinite(ratio) && ratio >= 0.05 && ratio <= 20 ? ratio : 0;
-    }
-
-    function isGeneratedImageNodeModel(nodeModel) {
-        if (!nodeModel || normalizeContentType(nodeModel) !== 'image') return false;
-
-        const metadata = getMetadata(nodeModel);
-        const operation = getMetadataValue(
-            metadata,
-            'RequestedMediaOperation',
-            'requestedMediaOperation'
-        ).toLowerCase();
-
-        return !!getMetadataValue(metadata, 'ImageGenerationProvider', 'imageGenerationProvider')
-            || !!getMetadataValue(metadata, 'GeneratedImageSourceWidth', 'generatedImageSourceWidth')
-            || !!getMetadataValue(metadata, 'GeneratedImageSourceHeight', 'generatedImageSourceHeight')
-            || !!getMetadataValue(metadata, 'CodexImageQuality', 'codexImageQuality')
-            || !!getMetadataValue(metadata, 'ImageRouterRevisedPrompt', 'imageRouterRevisedPrompt')
-            || operation === 'text2image'
-            || operation === 'image2image'
-            || operation === 'inpaint';
-    }
-
-    function getImageOriginalReference(nodeModel, assetUrls = null) {
-        if (!nodeModel || normalizeContentType(nodeModel) !== 'image') return '';
-
-        const metadata = getMetadata(nodeModel);
-        const candidates = [
-            assetUrls?.fullResUrl,
-            assetUrls?.originalUrl,
-            assetUrls?.originalPath,
-            getMetadataValue(metadata, 'OriginalUrl', 'originalUrl'),
-            getMetadataValue(metadata, 'OriginalPath', 'originalPath')
-        ];
-
-        for (const candidate of candidates) {
-            const normalized = String(candidate || '').trim();
-            if (normalized) return normalized;
-        }
-
-        return '';
-    }
-
-    function getGeneratedImageOriginalReference(nodeModel, assetUrls = null) {
-        if (!isGeneratedImageNodeModel(nodeModel)) return '';
-        return getImageOriginalReference(nodeModel, assetUrls);
-    }
-
-    function hasHighResolutionImageSource(nodeModel, assetUrls = null) {
-        return !!getImageOriginalReference(nodeModel, assetUrls);
-    }
-
-    function getOriginalAspectRatio(nodeEntry, fallbackWidth = 0, fallbackHeight = 0) {
-        const nodeModel = nodeEntry?.model ?? nodeEntry;
-        if (!nodeModel || normalizeContentType(nodeModel) !== 'image') return 0;
-
-        const metadata = getMetadata(nodeModel);
-        const metadataPairs = [
-            [
-                getMetadataValue(metadata, 'GeneratedImageSourceWidth', 'generatedImageSourceWidth'),
-                getMetadataValue(metadata, 'GeneratedImageSourceHeight', 'generatedImageSourceHeight')
-            ],
-            [
-                getMetadataValue(metadata, 'ImageIntrinsicWidth', 'imageIntrinsicWidth'),
-                getMetadataValue(metadata, 'ImageIntrinsicHeight', 'imageIntrinsicHeight')
-            ]
-        ];
-
-        for (const [width, height] of metadataPairs) {
-            const ratio = ratioFromPair(width, height);
-            if (ratio > 0) return ratio;
-        }
-
-        const imageElement = nodeEntry?.cssObject?.element?.querySelector?.('img') || null;
-        const naturalRatio = ratioFromPair(
-            imageElement?.naturalWidth || imageElement?.width,
-            imageElement?.naturalHeight || imageElement?.height
-        );
-        if (naturalRatio > 0) return naturalRatio;
-
-        const generatedDisplayRatio = ratioFromPair(
-            getMetadataValue(metadata, 'GeneratedImageDisplayWidth', 'generatedImageDisplayWidth'),
-            getMetadataValue(metadata, 'GeneratedImageDisplayHeight', 'generatedImageDisplayHeight')
-        );
-        if (generatedDisplayRatio > 0) return generatedDisplayRatio;
-
-        return ratioFromPair(
-            fallbackWidth || nodeModel.width || nodeModel.Width,
-            fallbackHeight || nodeModel.height || nodeModel.Height
-        );
-    }
-
-    function constrainBottomRightDimensions(
-        proposedWidth,
-        proposedHeight,
-        startWidth,
-        startHeight,
-        aspectRatio,
-        limits = {}) {
-        const ratio = toPositiveNumber(aspectRatio);
-        if (!(ratio > 0)) {
-            return {
-                width: Number(proposedWidth),
-                height: Number(proposedHeight),
-                aspectLocked: false
-            };
-        }
-
-        const minWidth = Math.max(1, toPositiveNumber(limits.minWidth) || 1);
-        const minHeight = Math.max(1, toPositiveNumber(limits.minHeight) || 1);
-        const maxWidth = Math.max(minWidth, toPositiveNumber(limits.maxWidth) || Number.MAX_SAFE_INTEGER);
-        const maxHeight = Math.max(minHeight, toPositiveNumber(limits.maxHeight) || Number.MAX_SAFE_INTEGER);
-        const width = Number(proposedWidth);
-        const height = Number(proposedHeight);
-        const initialWidth = Number(startWidth);
-        const initialHeight = Number(startHeight);
-        const widthMotion = Math.abs(width - initialWidth);
-        const heightMotionAsWidth = Math.abs(height - initialHeight) * ratio;
-        let targetHeight = widthMotion >= heightMotionAsWidth ? width / ratio : height;
-
-        const minimumLockedHeight = Math.max(minHeight, minWidth / ratio);
-        const maximumLockedHeight = Math.min(maxHeight, maxWidth / ratio);
-        targetHeight = Math.min(
-            Math.max(minimumLockedHeight, targetHeight),
-            Math.max(minimumLockedHeight, maximumLockedHeight)
-        );
-
-        return {
-            width: targetHeight * ratio,
-            height: targetHeight,
-            aspectLocked: true
-        };
-    }
-
-    function snapAspectLockedDimensions(width, height, aspectRatio, gridSize, limits = {}) {
-        const ratio = toPositiveNumber(aspectRatio);
-        const grid = toPositiveNumber(gridSize);
-        if (!(ratio > 0 && grid > 0)) {
-            return constrainBottomRightDimensions(width, height, width, height, ratio, limits);
-        }
-
-        const snappedWidth = Math.max(grid, Math.round(Number(width) / grid) * grid);
-        const snappedHeight = Math.max(grid, Math.round(Number(height) / grid) * grid);
-        const proposedWidth = ratio >= 1 ? snappedWidth : snappedHeight * ratio;
-        const proposedHeight = ratio >= 1 ? snappedWidth / ratio : snappedHeight;
-        return constrainBottomRightDimensions(
-            proposedWidth,
-            proposedHeight,
-            proposedWidth,
-            proposedHeight,
-            ratio,
-            limits
-        );
-    }
-
-    window.MindMapImagePolicy = {
-        build: BUILD_ID,
-        isGeneratedImageNodeModel,
-        getImageOriginalReference,
-        getGeneratedImageOriginalReference,
-        hasHighResolutionImageSource,
-        getOriginalAspectRatio,
-        constrainBottomRightDimensions,
-        snapAspectLockedDimensions
-    };
-
-    window.MindCanvasBuildInfo?.registerPart?.('imagePolicy', BUILD_ID, {
-        originalAfterLoad: true,
-        bottomRightAspectLock: true
-    });
-})();
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260819-image-original-resize-v2';
+
+    function normalizeContentType(nodeModel) {
+        return String(nodeModel?.contentType ?? nodeModel?.ContentType ?? '').trim().toLowerCase();
+    }
+
+    function getMetadata(nodeModel) {
+        return nodeModel?.metadata ?? nodeModel?.Metadata ?? {};
+    }
+
+    function getMetadataValue(metadata, ...keys) {
+        if (!metadata || typeof metadata !== 'object') return '';
+
+        for (const key of keys) {
+            const value = metadata[key];
+            if (value !== undefined && value !== null && String(value).trim()) {
+                return String(value).trim();
+            }
+        }
+
+        const wanted = new Set(keys.map(key => String(key).toLowerCase()));
+        for (const [key, value] of Object.entries(metadata)) {
+            if (wanted.has(String(key).toLowerCase())
+                && value !== undefined
+                && value !== null
+                && String(value).trim()) {
+                return String(value).trim();
+            }
+        }
+
+        return '';
+    }
+
+    function toPositiveNumber(value) {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
+    }
+
+    function ratioFromPair(width, height) {
+        const numericWidth = toPositiveNumber(width);
+        const numericHeight = toPositiveNumber(height);
+        if (!(numericWidth > 0 && numericHeight > 0)) return 0;
+
+        const ratio = numericWidth / numericHeight;
+        return Number.isFinite(ratio) && ratio >= 0.05 && ratio <= 20 ? ratio : 0;
+    }
+
+    function isGeneratedImageNodeModel(nodeModel) {
+        if (!nodeModel || normalizeContentType(nodeModel) !== 'image') return false;
+
+        const metadata = getMetadata(nodeModel);
+        const operation = getMetadataValue(
+            metadata,
+            'RequestedMediaOperation',
+            'requestedMediaOperation'
+        ).toLowerCase();
+
+        return !!getMetadataValue(metadata, 'ImageGenerationProvider', 'imageGenerationProvider')
+            || !!getMetadataValue(metadata, 'GeneratedImageSourceWidth', 'generatedImageSourceWidth')
+            || !!getMetadataValue(metadata, 'GeneratedImageSourceHeight', 'generatedImageSourceHeight')
+            || !!getMetadataValue(metadata, 'CodexImageQuality', 'codexImageQuality')
+            || !!getMetadataValue(metadata, 'ImageRouterRevisedPrompt', 'imageRouterRevisedPrompt')
+            || operation === 'text2image'
+            || operation === 'image2image'
+            || operation === 'inpaint';
+    }
+
+    function getImageOriginalReference(nodeModel, assetUrls = null) {
+        if (!nodeModel || normalizeContentType(nodeModel) !== 'image') return '';
+
+        const metadata = getMetadata(nodeModel);
+        const candidates = [
+            assetUrls?.fullResUrl,
+            assetUrls?.originalUrl,
+            assetUrls?.originalPath,
+            getMetadataValue(metadata, 'OriginalUrl', 'originalUrl'),
+            getMetadataValue(metadata, 'OriginalPath', 'originalPath')
+        ];
+
+        for (const candidate of candidates) {
+            const normalized = String(candidate || '').trim();
+            if (normalized) return normalized;
+        }
+
+        return '';
+    }
+
+    function getGeneratedImageOriginalReference(nodeModel, assetUrls = null) {
+        if (!isGeneratedImageNodeModel(nodeModel)) return '';
+        return getImageOriginalReference(nodeModel, assetUrls);
+    }
+
+    function hasHighResolutionImageSource(nodeModel, assetUrls = null) {
+        return !!getImageOriginalReference(nodeModel, assetUrls);
+    }
+
+    function getOriginalAspectRatio(nodeEntry, fallbackWidth = 0, fallbackHeight = 0) {
+        const nodeModel = nodeEntry?.model ?? nodeEntry;
+        if (!nodeModel || normalizeContentType(nodeModel) !== 'image') return 0;
+
+        const metadata = getMetadata(nodeModel);
+        const metadataPairs = [
+            [
+                getMetadataValue(metadata, 'GeneratedImageSourceWidth', 'generatedImageSourceWidth'),
+                getMetadataValue(metadata, 'GeneratedImageSourceHeight', 'generatedImageSourceHeight')
+            ],
+            [
+                getMetadataValue(metadata, 'ImageIntrinsicWidth', 'imageIntrinsicWidth'),
+                getMetadataValue(metadata, 'ImageIntrinsicHeight', 'imageIntrinsicHeight')
+            ]
+        ];
+
+        for (const [width, height] of metadataPairs) {
+            const ratio = ratioFromPair(width, height);
+            if (ratio > 0) return ratio;
+        }
+
+        const imageElement = nodeEntry?.cssObject?.element?.querySelector?.('img') || null;
+        const naturalRatio = ratioFromPair(
+            imageElement?.naturalWidth || imageElement?.width,
+            imageElement?.naturalHeight || imageElement?.height
+        );
+        if (naturalRatio > 0) return naturalRatio;
+
+        const generatedDisplayRatio = ratioFromPair(
+            getMetadataValue(metadata, 'GeneratedImageDisplayWidth', 'generatedImageDisplayWidth'),
+            getMetadataValue(metadata, 'GeneratedImageDisplayHeight', 'generatedImageDisplayHeight')
+        );
+        if (generatedDisplayRatio > 0) return generatedDisplayRatio;
+
+        return ratioFromPair(
+            fallbackWidth || nodeModel.width || nodeModel.Width,
+            fallbackHeight || nodeModel.height || nodeModel.Height
+        );
+    }
+
+    function constrainBottomRightDimensions(
+        proposedWidth,
+        proposedHeight,
+        startWidth,
+        startHeight,
+        aspectRatio,
+        limits = {}) {
+        const ratio = toPositiveNumber(aspectRatio);
+        if (!(ratio > 0)) {
+            return {
+                width: Number(proposedWidth),
+                height: Number(proposedHeight),
+                aspectLocked: false
+            };
+        }
+
+        const minWidth = Math.max(1, toPositiveNumber(limits.minWidth) || 1);
+        const minHeight = Math.max(1, toPositiveNumber(limits.minHeight) || 1);
+        const maxWidth = Math.max(minWidth, toPositiveNumber(limits.maxWidth) || Number.MAX_SAFE_INTEGER);
+        const maxHeight = Math.max(minHeight, toPositiveNumber(limits.maxHeight) || Number.MAX_SAFE_INTEGER);
+        const width = Number(proposedWidth);
+        const height = Number(proposedHeight);
+        const initialWidth = Number(startWidth);
+        const initialHeight = Number(startHeight);
+        const widthMotion = Math.abs(width - initialWidth);
+        const heightMotionAsWidth = Math.abs(height - initialHeight) * ratio;
+        let targetHeight = widthMotion >= heightMotionAsWidth ? width / ratio : height;
+
+        const minimumLockedHeight = Math.max(minHeight, minWidth / ratio);
+        const maximumLockedHeight = Math.min(maxHeight, maxWidth / ratio);
+        targetHeight = Math.min(
+            Math.max(minimumLockedHeight, targetHeight),
+            Math.max(minimumLockedHeight, maximumLockedHeight)
+        );
+
+        return {
+            width: targetHeight * ratio,
+            height: targetHeight,
+            aspectLocked: true
+        };
+    }
+
+    function snapAspectLockedDimensions(width, height, aspectRatio, gridSize, limits = {}) {
+        const ratio = toPositiveNumber(aspectRatio);
+        const grid = toPositiveNumber(gridSize);
+        if (!(ratio > 0 && grid > 0)) {
+            return constrainBottomRightDimensions(width, height, width, height, ratio, limits);
+        }
+
+        const snappedWidth = Math.max(grid, Math.round(Number(width) / grid) * grid);
+        const snappedHeight = Math.max(grid, Math.round(Number(height) / grid) * grid);
+        const proposedWidth = ratio >= 1 ? snappedWidth : snappedHeight * ratio;
+        const proposedHeight = ratio >= 1 ? snappedWidth / ratio : snappedHeight;
+        return constrainBottomRightDimensions(
+            proposedWidth,
+            proposedHeight,
+            proposedWidth,
+            proposedHeight,
+            ratio,
+            limits
+        );
+    }
+
+    window.MindMapImagePolicy = {
+        build: BUILD_ID,
+        isGeneratedImageNodeModel,
+        getImageOriginalReference,
+        getGeneratedImageOriginalReference,
+        hasHighResolutionImageSource,
+        getOriginalAspectRatio,
+        constrainBottomRightDimensions,
+        snapAspectLockedDimensions
+    };
+
+    window.MindCanvasBuildInfo?.registerPart?.('imagePolicy', BUILD_ID, {
+        originalAfterLoad: true,
+        bottomRightAspectLock: true
+    });
+})();