blue-chestnut-solar-expert 0.0.67 → 0.0.68

package/dist/stencil-library/constants-hboFofU4.js

@@ -0,0 +1,1522 @@
+
+if (typeof global === "undefined") { var global = globalThis || window || self; }
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getDefaultExportFromNamespaceIfPresent (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
+}
+
+function getDefaultExportFromNamespaceIfNotNamed (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+}
+
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var dist$1 = {};
+
+var geometry = {};
+
+var gridMatch = {};
+
+var dist = {};
+
+var shapes = {};
+
+var polygon = {};
+
+var hasRequiredPolygon;
+
+function requirePolygon () {
+	if (hasRequiredPolygon) return polygon;
+	hasRequiredPolygon = 1;
+	"use strict";
+	Object.defineProperty(polygon, "__esModule", { value: true });
+	polygon.PolygonType = polygon.Point = void 0;
+	class Point {
+	    constructor(x, y) {
+	        this.x = x;
+	        this.y = y;
+	    }
+	    equals(other) {
+	        return this.x === other.x && this.y === other.y;
+	    }
+	}
+	polygon.Point = Point;
+	var PolygonType;
+	(function (PolygonType) {
+	    PolygonType["ROOF"] = "roof";
+	    PolygonType["OBSTRUCTION"] = "obstruction";
+	})(PolygonType || (polygon.PolygonType = PolygonType = {}));
+	
+	return polygon;
+}
+
+var utils$1 = {};
+
+var hasRequiredUtils$1;
+
+function requireUtils$1 () {
+	if (hasRequiredUtils$1) return utils$1;
+	hasRequiredUtils$1 = 1;
+	"use strict";
+	Object.defineProperty(utils$1, "__esModule", { value: true });
+	utils$1.isPointInPolygon = isPointInPolygon;
+	utils$1.isPointOnBorder = isPointOnBorder;
+	function isPointInPolygon(point, polygon) {
+	    if (!polygon.closed || polygon.points.length < 3)
+	        return false;
+	    const num_vertices = polygon.points.length;
+	    const x = point.x;
+	    const y = point.y;
+	    let inside = false;
+	    let p1 = polygon.points[0];
+	    let p2;
+	    for (let i = 1; i <= num_vertices; i++) {
+	        p2 = polygon.points[i % num_vertices];
+	        if (y > Math.min(p1.y, p2.y)) {
+	            if (y <= Math.max(p1.y, p2.y)) {
+	                if (x <= Math.max(p1.x, p2.x)) {
+	                    const x_intersection = ((y - p1.y) * (p2.x - p1.x)) / (p2.y - p1.y) + p1.x;
+	                    if (p1.x === p2.x || x <= x_intersection) {
+	                        inside = !inside;
+	                    }
+	                }
+	            }
+	        }
+	        p1 = p2;
+	    }
+	    return inside;
+	}
+	function isPointOnBorder(point, polygon) {
+	    if (!polygon.closed || polygon.points.length < 3)
+	        return false;
+	    const x = point.x;
+	    const y = point.y;
+	    for (let i = 0; i < polygon.points.length; i++) {
+	        const p1 = polygon.points[i];
+	        const p2 = polygon.points[(i + 1) % polygon.points.length];
+	        const distance = Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+	        const distanceToPoint = Math.sqrt(Math.pow(p1.x - x, 2) + Math.pow(p1.y - y, 2));
+	        const distanceFromPoint = Math.sqrt(Math.pow(p2.x - x, 2) + Math.pow(p2.y - y, 2));
+	        if (distance === distanceToPoint + distanceFromPoint) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	
+	return utils$1;
+}
+
+var hasRequiredShapes;
+
+function requireShapes () {
+	if (hasRequiredShapes) return shapes;
+	hasRequiredShapes = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (shapes && shapes.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (shapes && shapes.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requirePolygon(), exports);
+		__exportStar(requireUtils$1(), exports);
+		
+	} (shapes));
+	return shapes;
+}
+
+var solar = {};
+
+var location = {};
+
+var hasRequiredLocation;
+
+function requireLocation () {
+	if (hasRequiredLocation) return location;
+	hasRequiredLocation = 1;
+	"use strict";
+	Object.defineProperty(location, "__esModule", { value: true });
+	
+	return location;
+}
+
+var solarPanel = {};
+
+var hasRequiredSolarPanel;
+
+function requireSolarPanel () {
+	if (hasRequiredSolarPanel) return solarPanel;
+	hasRequiredSolarPanel = 1;
+	"use strict";
+	Object.defineProperty(solarPanel, "__esModule", { value: true });
+	
+	return solarPanel;
+}
+
+var googleSolar = {};
+
+var hasRequiredGoogleSolar;
+
+function requireGoogleSolar () {
+	if (hasRequiredGoogleSolar) return googleSolar;
+	hasRequiredGoogleSolar = 1;
+	"use strict";
+	var __awaiter = (googleSolar && googleSolar.__awaiter) || function (thisArg, _arguments, P, generator) {
+	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+	    return new (P || (P = Promise))(function (resolve, reject) {
+	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+	        step((generator = generator.apply(thisArg, _arguments || [])).next());
+	    });
+	};
+	Object.defineProperty(googleSolar, "__esModule", { value: true });
+	googleSolar.findClosestBuilding = findClosestBuilding;
+	googleSolar.getDataLayerUrls = getDataLayerUrls;
+	function findClosestBuilding(location, apiKey) {
+	    return __awaiter(this, void 0, void 0, function* () {
+	        const args = {
+	            "location.latitude": location.lat().toFixed(5),
+	            "location.longitude": location.lng().toFixed(5),
+	        };
+	        const params = new URLSearchParams(Object.assign(Object.assign({}, args), { key: apiKey }));
+	        return fetch(`https://solar.googleapis.com/v1/buildingInsights:findClosest?${params}`).then((response) => __awaiter(this, void 0, void 0, function* () {
+	            const content = yield response.json();
+	            if (response.status != 200) {
+	                console.error("findClosestBuilding\n", content);
+	                throw content;
+	            }
+	            return content;
+	        }));
+	    });
+	}
+	function getDataLayerUrls(location, radiusMeters, apiKey) {
+	    return __awaiter(this, void 0, void 0, function* () {
+	        const args = {
+	            "location.latitude": location.latitude.toFixed(5),
+	            "location.longitude": location.longitude.toFixed(5),
+	            radius_meters: radiusMeters.toString(),
+	            required_quality: "LOW",
+	        };
+	        const params = new URLSearchParams(Object.assign(Object.assign({}, args), { key: apiKey }));
+	        return fetch(`https://solar.googleapis.com/v1/dataLayers:get?${params}`)
+	            .then((response) => __awaiter(this, void 0, void 0, function* () {
+	            const content = yield response.json();
+	            if (response.status != 200) {
+	                console.error("getDataLayerUrls\n", content);
+	                throw content;
+	            }
+	            return content;
+	        }));
+	    });
+	}
+	
+	return googleSolar;
+}
+
+var hasRequiredSolar;
+
+function requireSolar () {
+	if (hasRequiredSolar) return solar;
+	hasRequiredSolar = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (solar && solar.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (solar && solar.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireLocation(), exports);
+		__exportStar(requireSolarPanel(), exports);
+		__exportStar(requireGoogleSolar(), exports);
+		
+	} (solar));
+	return solar;
+}
+
+var heating = {};
+
+var hasRequiredHeating;
+
+function requireHeating () {
+	if (hasRequiredHeating) return heating;
+	hasRequiredHeating = 1;
+	"use strict";
+	Object.defineProperty(heating, "__esModule", { value: true });
+	
+	return heating;
+}
+
+var hasRequiredDist$1;
+
+function requireDist$1 () {
+	if (hasRequiredDist$1) return dist;
+	hasRequiredDist$1 = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (dist && dist.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (dist && dist.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireShapes(), exports);
+		__exportStar(requireSolar(), exports);
+		__exportStar(requireHeating(), exports);
+		
+	} (dist));
+	return dist;
+}
+
+var fitting = {};
+
+var utils = {};
+
+var solarApi = {};
+
+var hasRequiredSolarApi;
+
+function requireSolarApi () {
+	if (hasRequiredSolarApi) return solarApi;
+	hasRequiredSolarApi = 1;
+	"use strict";
+	var __awaiter = (solarApi && solarApi.__awaiter) || function (thisArg, _arguments, P, generator) {
+	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+	    return new (P || (P = Promise))(function (resolve, reject) {
+	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+	        step((generator = generator.apply(thisArg, _arguments || [])).next());
+	    });
+	};
+	Object.defineProperty(solarApi, "__esModule", { value: true });
+	solarApi.fetchSolarData = fetchSolarData;
+	solarApi.getPixelInMeters = getPixelInMeters;
+	function fetchSolarData(latitude, longitude, apiKey) {
+	    return __awaiter(this, void 0, void 0, function* () {
+	        if (latitude === 0 || longitude === 0) {
+	            return null;
+	        }
+	        try {
+	            const args = {
+	                "location.latitude": latitude.toFixed(5),
+	                "location.longitude": longitude.toFixed(5),
+	            };
+	            const params = new URLSearchParams(Object.assign(Object.assign({}, args), { key: apiKey }));
+	            const response = yield fetch(`https://solar.googleapis.com/v1/buildingInsights:findClosest?${params}`);
+	            if (!response.ok) {
+	                const errorText = yield response.text();
+	                throw new Error(`HTTP error! status: ${response.status}, body: ${errorText}`);
+	            }
+	            const contentType = response.headers.get("content-type");
+	            if (!contentType || !contentType.includes("application/json")) {
+	                const text = yield response.text();
+	                console.error("Unexpected content type:", contentType, "Response:", text);
+	                return null;
+	            }
+	            const rawData = yield response.json();
+	            return rawData;
+	        }
+	        catch (error) {
+	            console.error("Error fetching solar data:", error);
+	            if (error instanceof TypeError &&
+	                error.message === "Failed to fetch") {
+	                throw new Error("Unable to connect to the solar data API.");
+	            }
+	            throw error;
+	        }
+	    });
+	}
+	function getPixelInMeters(rgbTiff) {
+	    const latDiff = rgbTiff.bounds.north - rgbTiff.bounds.south;
+	    const pixelHeight = rgbTiff.height;
+	    const pixelInMeters = latDiff * 111320 / pixelHeight;
+	    return pixelInMeters;
+	}
+	
+	return solarApi;
+}
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (utils && utils.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (utils && utils.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.latLngToPixel = latLngToPixel;
+		const harmonia_types_1 = requireDist$1();
+		__exportStar(/*@__PURE__*/ requireSolarApi(), exports);
+		function latLngToPixel(bounds, canvas, latLng) {
+		    const ctx = canvas.getContext("2d");
+		    if (!ctx) {
+		        throw new Error("Canvas context not found");
+		    }
+		    const latToPixel = (lat) => {
+		        return canvas.height *
+		            (1 - (lat - bounds.south) / (bounds.north - bounds.south));
+		    };
+		    const lngToPixel = (lng) => {
+		        return canvas.width * (lng - bounds.west) / (bounds.east - bounds.west);
+		    };
+		    return new harmonia_types_1.Point(lngToPixel(latLng.longitude), latToPixel(latLng.latitude));
+		}
+		
+	} (utils));
+	return utils;
+}
+
+var hasRequiredFitting;
+
+function requireFitting () {
+	if (hasRequiredFitting) return fitting;
+	hasRequiredFitting = 1;
+	"use strict";
+	Object.defineProperty(fitting, "__esModule", { value: true });
+	fitting.projectPoint = projectPoint;
+	fitting.projectPolygon = projectPolygon;
+	fitting.intersects = intersects;
+	fitting.offsetPolygon = offsetPolygon;
+	fitting.getBestFittingRoofSegment = getBestFittingRoofSegment;
+	const harmonia_types_1 = requireDist$1();
+	const utils_1 = /*@__PURE__*/ requireUtils();
+	function projectPoint(point, azimuth) {
+	    const angle = azimuth * (Math.PI / 180);
+	    const x = point.x * Math.cos(angle) - point.y * Math.sin(angle);
+	    const y = point.x * Math.sin(angle) + point.y * Math.cos(angle);
+	    return new harmonia_types_1.Point(x, y);
+	}
+	function projectPolygon(polygon, azimuth) {
+	    return {
+	        points: polygon.points.map((point) => projectPoint(point, azimuth)),
+	        type: polygon.type,
+	        closed: polygon.closed,
+	        id: polygon.id,
+	    };
+	}
+	function intersects(line1, line2) {
+	    const p1 = line1.start;
+	    const p2 = line1.end;
+	    const p3 = line2.start;
+	    const p4 = line2.end;
+	    if (p1.equals(p3) ||
+	        p1.equals(p4) ||
+	        p2.equals(p3) ||
+	        p2.equals(p4)) {
+	        return false;
+	    }
+	    const d1 = (p4.x - p3.x) * (p1.y - p3.y) - (p4.y - p3.y) * (p1.x - p3.x);
+	    const d2 = (p4.x - p3.x) * (p2.y - p3.y) - (p4.y - p3.y) * (p2.x - p3.x);
+	    const d3 = (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
+	    const d4 = (p2.x - p1.x) * (p4.y - p1.y) - (p2.y - p1.y) * (p4.x - p1.x);
+	    return (d1 * d2 < 0) && (d3 * d4 < 0);
+	}
+	function offsetPolygon(polygon, offset) {
+	    if (polygon.points.length === 0) {
+	        return { polygon: polygon, offset: { x: 0, y: 0 } };
+	    }
+	    let offsetX = 0;
+	    let offsetY = 0;
+	    if (!offset) {
+	        const minX = Math.min(...polygon.points.map((point) => point.x));
+	        const minY = Math.min(...polygon.points.map((point) => point.y));
+	        const maxX = Math.max(...polygon.points.map((point) => point.x));
+	        const maxY = Math.max(...polygon.points.map((point) => point.y));
+	        offsetX = minX + (maxX - minX) / 2;
+	        offsetY = minY + (maxY - minY) / 2;
+	    }
+	    else {
+	        offsetX = offset.x;
+	        offsetY = offset.y;
+	    }
+	    const newPoints = polygon.points.map((point) => new harmonia_types_1.Point(point.x - offsetX, point.y - offsetY));
+	    return {
+	        polygon: Object.assign(Object.assign({}, polygon), { points: newPoints }),
+	        offset: { x: offsetX, y: offsetY },
+	    };
+	}
+	function getBestFittingRoofSegment(roof, roofSegmentStats, bounds, canvas) {
+	    const polygonBounds = {
+	        minX: Math.min(...roof.points.map((p) => p.x)),
+	        maxX: Math.max(...roof.points.map((p) => p.x)),
+	        minY: Math.min(...roof.points.map((p) => p.y)),
+	        maxY: Math.max(...roof.points.map((p) => p.y)),
+	    };
+	    let bestSegment = null;
+	    let bestIoU = 0;
+	    for (const segment of roofSegmentStats) {
+	        const sw = (0, utils_1.latLngToPixel)(bounds, canvas, {
+	            latitude: segment.boundingBox.sw.latitude,
+	            longitude: segment.boundingBox.sw.longitude,
+	        });
+	        const ne = (0, utils_1.latLngToPixel)(bounds, canvas, {
+	            latitude: segment.boundingBox.ne.latitude,
+	            longitude: segment.boundingBox.ne.longitude,
+	        });
+	        const segmentBounds = {
+	            minX: sw.x,
+	            maxX: ne.x,
+	            minY: ne.y,
+	            maxY: sw.y,
+	        };
+	        const interLeft = Math.max(polygonBounds.minX, segmentBounds.minX);
+	        const interRight = Math.min(polygonBounds.maxX, segmentBounds.maxX);
+	        const interTop = Math.max(polygonBounds.minY, segmentBounds.minY);
+	        const interBottom = Math.min(polygonBounds.maxY, segmentBounds.maxY);
+	        const interWidth = interRight - interLeft;
+	        const interHeight = interBottom - interTop;
+	        let intersectionArea = 0;
+	        if (interWidth > 0 && interHeight > 0) {
+	            intersectionArea = interWidth * interHeight;
+	        }
+	        const polygonArea = (polygonBounds.maxX - polygonBounds.minX) *
+	            (polygonBounds.maxY - polygonBounds.minY);
+	        const segmentArea = (segmentBounds.maxX - segmentBounds.minX) *
+	            (segmentBounds.maxY - segmentBounds.minY);
+	        const unionArea = polygonArea + segmentArea - intersectionArea;
+	        const iou = unionArea > 0 ? intersectionArea / unionArea : 0;
+	        if (iou > bestIoU) {
+	            bestIoU = iou;
+	            bestSegment = segment;
+	        }
+	    }
+	    return bestSegment;
+	}
+	
+	return fitting;
+}
+
+var hasRequiredGridMatch;
+
+function requireGridMatch () {
+	if (hasRequiredGridMatch) return gridMatch;
+	hasRequiredGridMatch = 1;
+	"use strict";
+	Object.defineProperty(gridMatch, "__esModule", { value: true });
+	gridMatch.generateGrid = generateGrid;
+	gridMatch.solarPanelInObstacle = solarPanelInObstacle;
+	gridMatch.solarPanelInPolygon = solarPanelInPolygon;
+	gridMatch.isPanelObstructed = isPanelObstructed;
+	gridMatch.getSolarPanelsInPolygon = getSolarPanelsInPolygon;
+	gridMatch.getOptimalSolarPosition = getOptimalSolarPosition;
+	gridMatch.insetPolygon = insetPolygon;
+	gridMatch.getOptimalSolarPositionFully = getOptimalSolarPositionFully;
+	const harmonia_types_1 = requireDist$1();
+	const fitting_1 = /*@__PURE__*/ requireFitting();
+	function generateGrid(minMax, solarPanel, horizontal, anker, rowSpacing, columnSpacing) {
+	    const grid = [];
+	    const width = horizontal ? solarPanel.heightMeters : solarPanel.widthMeters;
+	    const widthCount = Math.ceil((minMax.maxX - minMax.minX) / width);
+	    const height = horizontal
+	        ? solarPanel.widthMeters
+	        : solarPanel.heightMeters;
+	    const heightCount = Math.ceil((minMax.maxY - minMax.minY) / height);
+	    const widthOffset = width / 2;
+	    const heightOffset = height / 2;
+	    const startX = anker.x -
+	        (Math.ceil((anker.x - minMax.minX) / width) * width);
+	    const startY = anker.y -
+	        (Math.ceil((anker.y - minMax.minY) / height) * height);
+	    for (let i = 0; i < heightCount; i++) {
+	        const row = [];
+	        for (let j = 0; j < widthCount; j++) {
+	            const x = startX + j * width + j * columnSpacing + widthOffset;
+	            const y = startY + i * height + i * rowSpacing + heightOffset;
+	            const positionedSolarPanel = {
+	                panel: solarPanel,
+	                pixelPosition: new harmonia_types_1.Point(x, y),
+	                horizontal: horizontal,
+	            };
+	            row.push(positionedSolarPanel);
+	        }
+	        grid.push(row);
+	    }
+	    return grid;
+	}
+	function getSolarPanelLines(positionedSolarPanel, horizontal) {
+	    const width = horizontal
+	        ? positionedSolarPanel.panel.heightMeters
+	        : positionedSolarPanel.panel.widthMeters;
+	    const height = horizontal
+	        ? positionedSolarPanel.panel.widthMeters
+	        : positionedSolarPanel.panel.heightMeters;
+	    const p1 = new harmonia_types_1.Point(positionedSolarPanel.pixelPosition.x - width / 2, positionedSolarPanel.pixelPosition.y - height / 2);
+	    const p2 = new harmonia_types_1.Point(positionedSolarPanel.pixelPosition.x - width / 2, positionedSolarPanel.pixelPosition.y + height / 2);
+	    const p3 = new harmonia_types_1.Point(positionedSolarPanel.pixelPosition.x + width / 2, positionedSolarPanel.pixelPosition.y + height / 2);
+	    const p4 = new harmonia_types_1.Point(positionedSolarPanel.pixelPosition.x + width / 2, positionedSolarPanel.pixelPosition.y - height / 2);
+	    const lines = [
+	        {
+	            start: p1,
+	            end: p2,
+	        },
+	        {
+	            start: p2,
+	            end: p3,
+	        },
+	        {
+	            start: p3,
+	            end: p4,
+	        },
+	        {
+	            start: p4,
+	            end: p1,
+	        },
+	    ];
+	    return lines;
+	}
+	function solarPanelInObstacle(positionedSolarPanel, obstacle, horizontal) {
+	    const lines = getSolarPanelLines(positionedSolarPanel, horizontal);
+	    if ((0, harmonia_types_1.isPointInPolygon)(positionedSolarPanel.pixelPosition, obstacle)) {
+	        return true;
+	    }
+	    for (let i = 0; i < obstacle.points.length; i++) {
+	        const point = obstacle.points[i];
+	        const nextPoint = obstacle.points[(i + 1) % obstacle.points.length];
+	        const border = {
+	            start: point,
+	            end: nextPoint,
+	        };
+	        for (const line of lines) {
+	            if ((0, fitting_1.intersects)(line, border)) {
+	                return true;
+	            }
+	        }
+	    }
+	    return false;
+	}
+	function solarPanelInPolygon(positionedSolarPanel, polygon, horizontal) {
+	    const lines = getSolarPanelLines(positionedSolarPanel, horizontal);
+	    for (let i = 0; i < polygon.points.length; i++) {
+	        const point = polygon.points[i];
+	        const nextPoint = polygon.points[(i + 1) % polygon.points.length];
+	        const border = {
+	            start: point,
+	            end: nextPoint,
+	        };
+	        for (const line of lines) {
+	            if ((0, fitting_1.intersects)(line, border)) {
+	                return false;
+	            }
+	        }
+	    }
+	    return (0, harmonia_types_1.isPointInPolygon)(positionedSolarPanel.pixelPosition, polygon);
+	}
+	function isPanelObstructed(positionedSolarPanel, obstacles, horizontal) {
+	    for (const obstacle of obstacles) {
+	        if (solarPanelInObstacle(positionedSolarPanel, obstacle.polygon, horizontal)) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	function getSolarPanelsInPolygon(grid, polygon, horizontal, obstacles) {
+	    const solarPanels = [];
+	    for (const row of grid) {
+	        let newRow = [];
+	        for (const positionedSolarPanel of row) {
+	            const isObstructed = isPanelObstructed(positionedSolarPanel, obstacles, horizontal);
+	            if (solarPanelInPolygon(positionedSolarPanel, polygon, horizontal) && !isObstructed) {
+	                newRow.push(positionedSolarPanel);
+	            }
+	        }
+	        solarPanels.push(newRow);
+	    }
+	    return solarPanels;
+	}
+	function getOptimalSolarPosition(roof, obstacles, solarPanel, angle, columnSpacing, rowSpacing) {
+	    const minX = Math.min(...roof.points.map((p) => p.x));
+	    const maxX = Math.max(...roof.points.map((p) => p.x));
+	    const minY = Math.min(...roof.points.map((p) => p.y));
+	    const maxY = Math.max(...roof.points.map((p) => p.y));
+	    const minMax = {
+	        minX: minX,
+	        maxX: maxX,
+	        minY: minY,
+	        maxY: maxY,
+	    };
+	    const horizontalSolarPanel = Object.assign(Object.assign({}, solarPanel), { widthMeters: solarPanel.widthMeters * Math.cos(angle * Math.PI / 180), heightMeters: solarPanel.heightMeters });
+	    const verticalSolarPanel = Object.assign(Object.assign({}, solarPanel), { widthMeters: solarPanel.widthMeters, heightMeters: solarPanel.heightMeters * Math.cos(angle * Math.PI / 180) });
+	    let solarPanels = [];
+	    let numberOfPanels = 0;
+	    for (const point of roof.points) {
+	        for (const horizontal of [true]) {
+	            const grid = generateGrid(minMax, verticalSolarPanel, horizontal, point, rowSpacing, columnSpacing);
+	            const solarPanelsInPolygon = getSolarPanelsInPolygon(grid, roof, horizontal, obstacles);
+	            const numberOfPanelsInPolygon = solarPanelsInPolygon.reduce((acc, row) => acc + row.length, 0);
+	            if (numberOfPanelsInPolygon > numberOfPanels) {
+	                numberOfPanels = numberOfPanelsInPolygon;
+	                solarPanels = solarPanelsInPolygon;
+	            }
+	        }
+	        break;
+	    }
+	    return solarPanels;
+	}
+	function projectObstacles(obstacles, azimuth, offset, inset) {
+	    const result = [];
+	    for (const obstacle of obstacles) {
+	        const offsetObstacle = (0, fitting_1.offsetPolygon)(obstacle, offset);
+	        const projectedObstacle = (0, fitting_1.projectPolygon)(offsetObstacle.polygon, -azimuth);
+	        const insetObstacle = insetPolygon(projectedObstacle, -inset);
+	        const minX = Math.min(...insetObstacle.points.map((p) => p.x));
+	        const maxX = Math.max(...insetObstacle.points.map((p) => p.x));
+	        const minY = Math.min(...insetObstacle.points.map((p) => p.y));
+	        const maxY = Math.max(...insetObstacle.points.map((p) => p.y));
+	        const boundingBox = {
+	            minX: minX,
+	            maxX: maxX,
+	            minY: minY,
+	            maxY: maxY,
+	        };
+	        result.push({
+	            polygon: projectedObstacle,
+	            boundingBox: boundingBox,
+	        });
+	    }
+	    return result;
+	}
+	function isClockwise(points) {
+	    let sum = 0;
+	    for (let i = 0; i < points.length; i++) {
+	        const curr = points[i];
+	        const next = points[(i + 1) % points.length];
+	        sum += (next.x - curr.x) * (next.y + curr.y);
+	    }
+	    return sum > 0;
+	}
+	function insetPolygon(polygon, inset) {
+	    const points = polygon.points;
+	    const isClockwisePolygon = isClockwise(points);
+	    inset = inset * Math.sqrt(2) * (isClockwisePolygon ? -1 : 1);
+	    const insetPoints = [];
+	    for (let i = 0; i < points.length; i++) {
+	        const prev = points[(i - 1 + points.length) % points.length];
+	        const curr = points[i];
+	        const next = points[(i + 1) % points.length];
+	        const v1 = {
+	            x: curr.x - prev.x,
+	            y: curr.y - prev.y,
+	        };
+	        const v2 = {
+	            x: next.x - curr.x,
+	            y: next.y - curr.y,
+	        };
+	        const perp1 = {
+	            x: -v1.y,
+	            y: v1.x,
+	        };
+	        const perp2 = {
+	            x: -v2.y,
+	            y: v2.x,
+	        };
+	        const length1 = Math.sqrt(perp1.x * perp1.x + perp1.y * perp1.y);
+	        const length2 = Math.sqrt(perp2.x * perp2.x + perp2.y * perp2.y);
+	        perp1.x /= length1;
+	        perp1.y /= length1;
+	        perp2.x /= length2;
+	        perp2.y /= length2;
+	        const bisector = {
+	            x: perp1.x + perp2.x,
+	            y: perp1.y + perp2.y,
+	        };
+	        const bisectorLength = Math.sqrt(bisector.x * bisector.x + bisector.y * bisector.y);
+	        bisector.x /= bisectorLength;
+	        bisector.y /= bisectorLength;
+	        const insetPoint = new harmonia_types_1.Point(curr.x + bisector.x * inset, curr.y + bisector.y * inset);
+	        insetPoints.push(insetPoint);
+	    }
+	    return {
+	        points: insetPoints,
+	        type: polygon.type,
+	        closed: polygon.closed,
+	        id: polygon.id,
+	        area: polygon.area,
+	    };
+	}
+	function getOptimalSolarPositionFully(roof, obstacles, solarPanel, azimuth, inset, angle, columnSpacing, rowSpacing) {
+	    const insetRoof = insetPolygon(roof, inset);
+	    const offset = (0, fitting_1.offsetPolygon)(insetRoof);
+	    const projectedOffset = (0, fitting_1.projectPolygon)(offset.polygon, -azimuth);
+	    const projectedObstacles = projectObstacles(obstacles, azimuth, offset.offset, inset);
+	    const horizontalSolarPanels = getOptimalSolarPosition(projectedOffset, projectedObstacles, solarPanel, angle, columnSpacing, rowSpacing);
+	    const unprojectedPanels = [];
+	    for (const panel of horizontalSolarPanels.flat()) {
+	        const unprojectedPanel = (0, fitting_1.projectPoint)(panel.pixelPosition, azimuth);
+	        const offsetPosition = new harmonia_types_1.Point(unprojectedPanel.x + offset.offset.x, unprojectedPanel.y + offset.offset.y);
+	        unprojectedPanels.push({
+	            panel: panel.panel,
+	            pixelPosition: offsetPosition,
+	            horizontal: panel.horizontal,
+	        });
+	    }
+	    return unprojectedPanels;
+	}
+	
+	return gridMatch;
+}
+
+var hasRequiredGeometry;
+
+function requireGeometry () {
+	if (hasRequiredGeometry) return geometry;
+	hasRequiredGeometry = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (geometry && geometry.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (geometry && geometry.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(/*@__PURE__*/ requireGridMatch(), exports);
+		__exportStar(/*@__PURE__*/ requireFitting(), exports);
+		
+	} (geometry));
+	return geometry;
+}
+
+var simulation$1 = {};
+
+var simulation = {};
+
+var solarCurves = {};
+
+var hasRequiredSolarCurves;
+
+function requireSolarCurves () {
+	if (hasRequiredSolarCurves) return solarCurves;
+	hasRequiredSolarCurves = 1;
+	"use strict";
+	Object.defineProperty(solarCurves, "__esModule", { value: true });
+	solarCurves.SOLAR_RADIATION = solarCurves.CONSUMPTION_PROFILES = void 0;
+	solarCurves.getSolarRadiation = getSolarRadiation;
+	const SOLAR_RADIATION = [
+	    0,
+	    0,
+	    0,
+	    0,
+	    0,
+	    0,
+	    0,
+	    0.1,
+	    0.2,
+	    0.4,
+	    0.8,
+	    0.9,
+	    1,
+	    0.95,
+	    0.9,
+	    0.7,
+	    0.5,
+	    0.3,
+	    0.16,
+	    0.02,
+	    0,
+	    0,
+	    0,
+	    0,
+	];
+	solarCurves.SOLAR_RADIATION = SOLAR_RADIATION;
+	function getSolarRadiation(discountFactor) {
+	    return SOLAR_RADIATION.map((value) => value * discountFactor);
+	}
+	const CONSUMPTION_PROFILES = {
+	    mostly_at_home: [
+	        0.1,
+	        0.1,
+	        0.1,
+	        0.1,
+	        0.1,
+	        0.15,
+	        0.23,
+	        0.26,
+	        0.16,
+	        0.16,
+	        0.15,
+	        0.19,
+	        0.23,
+	        0.24,
+	        0.35,
+	        0.28,
+	        0.275,
+	        0.8,
+	        0.78,
+	        0.74,
+	        0.75,
+	        0.73,
+	        0.26,
+	        0.1,
+	    ],
+	    mostly_away: [
+	        0.1,
+	        0.1,
+	        0.1,
+	        0.1,
+	        0.1,
+	        0.15,
+	        0.29,
+	        0.32,
+	        0.25,
+	        0.15,
+	        0.12,
+	        0.14,
+	        0.15,
+	        0.12,
+	        0.16,
+	        0.21,
+	        0.285,
+	        1,
+	        0.81,
+	        0.77,
+	        0.79,
+	        0.73,
+	        0.26,
+	        0.1,
+	    ],
+	};
+	solarCurves.CONSUMPTION_PROFILES = CONSUMPTION_PROFILES;
+	
+	return solarCurves;
+}
+
+var types = {};
+
+var hasRequiredTypes;
+
+function requireTypes () {
+	if (hasRequiredTypes) return types;
+	hasRequiredTypes = 1;
+	"use strict";
+	Object.defineProperty(types, "__esModule", { value: true });
+	types.DEFAULT_GENERAL_SIMULATION_CONFIG = void 0;
+	types.DEFAULT_GENERAL_SIMULATION_CONFIG = {
+	    simulationYears: 25,
+	};
+	
+	return types;
+}
+
+var hasRequiredSimulation$1;
+
+function requireSimulation$1 () {
+	if (hasRequiredSimulation$1) return simulation;
+	hasRequiredSimulation$1 = 1;
+	"use strict";
+	Object.defineProperty(simulation, "__esModule", { value: true });
+	simulation.generateElectricCarChargingHours = generateElectricCarChargingHours;
+	simulation.simulateDay = simulateDay;
+	simulation.simulate = simulate;
+	const solarCurves_1 = /*@__PURE__*/ requireSolarCurves();
+	const types_1 = /*@__PURE__*/ requireTypes();
+	function generateElectricCarChargingHours(start, end) {
+	    let hours = new Array(24).fill(false);
+	    if (start < end) {
+	        for (let i = start; i <= end; i++) {
+	            hours[i] = true;
+	        }
+	    }
+	    else {
+	        for (let i = start; i <= 24; i++) {
+	            hours[i] = true;
+	        }
+	        for (let i = 0; i <= end; i++) {
+	            hours[i] = true;
+	        }
+	    }
+	    return hours;
+	}
+	function simulateDay(production, consumption, dailyConsumption, battery) {
+	    let batteryCharge = 0;
+	    let soldEnergy = 0;
+	    let energyUsageOfProduction = 0;
+	    for (let hour = 0; hour < production.length; hour++) {
+	        const energyDifference = production[hour] - consumption[hour];
+	        if (energyDifference > 0) {
+	            energyUsageOfProduction += consumption[hour];
+	            if (batteryCharge < battery &&
+	                batteryCharge + energyDifference <= battery) {
+	                batteryCharge = batteryCharge + energyDifference;
+	            }
+	            else if (batteryCharge < battery) {
+	                const batteryDifference = battery - batteryCharge;
+	                batteryCharge = battery;
+	                soldEnergy += energyDifference - batteryDifference;
+	            }
+	            else {
+	                soldEnergy += energyDifference;
+	            }
+	        }
+	        else {
+	            if (batteryCharge > 0) {
+	                if (batteryCharge >= -energyDifference) {
+	                    batteryCharge += energyDifference;
+	                    energyUsageOfProduction += consumption[hour];
+	                }
+	                else {
+	                    energyUsageOfProduction += production[hour] + batteryCharge;
+	                    batteryCharge = 0;
+	                }
+	            }
+	            else {
+	                energyUsageOfProduction += production[hour];
+	            }
+	        }
+	    }
+	    if (batteryCharge > 0) {
+	        soldEnergy += batteryCharge;
+	    }
+	    const autonomy = energyUsageOfProduction / dailyConsumption;
+	    return {
+	        autonomy: autonomy > 1 ? 1 : autonomy,
+	        soldEnergy,
+	        energyUsageOfProduction,
+	    };
+	}
+	function simulate(config) {
+	    const generalConfig = Object.assign(Object.assign({}, types_1.DEFAULT_GENERAL_SIMULATION_CONFIG), config.general);
+	    const consumption = solarCurves_1.CONSUMPTION_PROFILES[config.householdConsumption.consumptionProfile];
+	    const norm = consumption.reduce((acc, curr) => acc + curr, 0);
+	    let additionalConsumption = 0;
+	    if (config.heatPump) {
+	        additionalConsumption =
+	            (config.heatPump.m2 || 0) * config.heatPump.consumptionPerM2 || 0;
+	    }
+	    let electricCarConsumption = 0;
+	    let electricCarNorm = 1;
+	    let electricCarChargingHours = consumption.map((_) => false);
+	    if (config.electricCar) {
+	        electricCarChargingHours = config.electricCar.chargingHours;
+	        const dailyCarUsage = config.electricCar.averageKilometersPerDay / 100 *
+	            config.electricCar.consumptionkWhPer100km;
+	        electricCarConsumption = Math.min(dailyCarUsage, config.electricCar.batteryKWh);
+	        electricCarNorm = config.electricCar.chargingHours.reduce((acc, curr) => acc + (curr ? 1 : 0), 0);
+	        if (electricCarNorm === 0) {
+	            electricCarNorm = 1;
+	        }
+	    }
+	    let systemSize = 0;
+	    if (config.solarSystems) {
+	        systemSize = Object.values(config.solarSystems).reduce((acc, curr) => {
+	            return acc + curr.numberOfPanels * curr.panelType.kWattPeak;
+	        }, 0);
+	    }
+	    else if (config.solarSystem) {
+	        console.warn("solarSystem is deprecated, use solarSystems instead");
+	        systemSize = config.solarSystem.numberOfPanels *
+	            config.solarSystem.panelType.kWattPeak;
+	    }
+	    else {
+	        throw new Error("No solar system found");
+	    }
+	    const summerProduction = (0, solarCurves_1.getSolarRadiation)(config.solarRadiation.summerFactor * systemSize);
+	    const winterProduction = (0, solarCurves_1.getSolarRadiation)(config.solarRadiation.winterFactor * systemSize);
+	    const summerConsumptionWholeDay = config.householdConsumption.averageConsumption *
+	        config.householdConsumption.summerConsumptionFactor +
+	        additionalConsumption *
+	            config.householdConsumption.summerConsumptionFactor;
+	    const summerConsumptionDaily = consumption.map((c, i) => c / norm * summerConsumptionWholeDay +
+	        electricCarConsumption / electricCarNorm *
+	            (electricCarChargingHours[i] ? 1 : 0));
+	    const winterConsumptionWholeDay = config.householdConsumption.averageConsumption *
+	        config.householdConsumption.winterConsumptionFactor +
+	        additionalConsumption *
+	            config.householdConsumption.winterConsumptionFactor;
+	    const winterConsumptionDaily = consumption.map((c, i) => c / norm * winterConsumptionWholeDay +
+	        electricCarConsumption / electricCarNorm *
+	            (electricCarChargingHours[i] ? 1 : 0));
+	    const summerDay = simulateDay(summerProduction, summerConsumptionDaily, summerConsumptionWholeDay + electricCarConsumption, config.batteryKWh);
+	    const winterDay = simulateDay(winterProduction, winterConsumptionDaily, winterConsumptionWholeDay + electricCarConsumption, config.batteryKWh);
+	    let savedCosts = 0;
+	    let savedCostsByYear = [];
+	    const soldEnergy = (summerDay.soldEnergy + winterDay.soldEnergy) / 2;
+	    const ownConsumption = (summerDay.energyUsageOfProduction +
+	        winterDay.energyUsageOfProduction) / 2;
+	    let energyPrice = config.electricityPrice.purchase;
+	    for (let i = 0; i < generalConfig.simulationYears; i++) {
+	        const savedCostsThisYear = ownConsumption * energyPrice * 365;
+	        savedCosts += savedCostsThisYear;
+	        savedCostsByYear.push(savedCostsThisYear);
+	        energyPrice = (1 + config.electricityPrice.increase) * energyPrice;
+	    }
+	    const totalEnergyProduction = (summerProduction.reduce((acc, curr) => acc + curr, 0) +
+	        winterProduction.reduce((acc, curr) => acc + curr, 0)) / 2;
+	    return {
+	        autonomy: (summerDay.autonomy + winterDay.autonomy) / 2,
+	        compensationPerDay: soldEnergy * config.electricityPrice.sell,
+	        byYearSavedCosts: savedCostsByYear,
+	        totalEnergyConsumptionDay: (summerConsumptionWholeDay + winterConsumptionWholeDay) / 2 +
+	            electricCarConsumption,
+	        totalEnergyProduction,
+	    };
+	}
+	
+	return simulation;
+}
+
+var heatingSimulation = {};
+
+var heatingConstants = {};
+
+var hasRequiredHeatingConstants;
+
+function requireHeatingConstants () {
+	if (hasRequiredHeatingConstants) return heatingConstants;
+	hasRequiredHeatingConstants = 1;
+	"use strict";
+	Object.defineProperty(heatingConstants, "__esModule", { value: true });
+	heatingConstants.SYSTEM_EFFICIENCY = heatingConstants.INSULATION_FACTORS = heatingConstants.EQUIPMENT_COSTS = heatingConstants.DISTRIBUTION_EFFICIENCY = heatingConstants.DISTRIBUTION_COSTS = heatingConstants.CO2_EMISSIONS = heatingConstants.CLIMATE_DATA = void 0;
+	const CLIMATE_DATA = {
+	    "Zone 1": { heatingDegreeHours: 1200, coolingDegreeHours: 2800 },
+	    "Zone 2": { heatingDegreeHours: 1800, coolingDegreeHours: 2200 },
+	    "Zone 3": { heatingDegreeHours: 2400, coolingDegreeHours: 1800 },
+	    "Zone 4": { heatingDegreeHours: 3200, coolingDegreeHours: 1400 },
+	    "Zone 5": { heatingDegreeHours: 4200, coolingDegreeHours: 1000 },
+	    "Zone 6": { heatingDegreeHours: 5400, coolingDegreeHours: 600 },
+	    "Zone 7": { heatingDegreeHours: 6800, coolingDegreeHours: 300 },
+	    "Zone 8": { heatingDegreeHours: 8400, coolingDegreeHours: 100 },
+	};
+	heatingConstants.CLIMATE_DATA = CLIMATE_DATA;
+	const INSULATION_FACTORS = {
+	    poor: 1.4,
+	    fair: 1.2,
+	    good: 1.0,
+	    excellent: 0.8,
+	};
+	heatingConstants.INSULATION_FACTORS = INSULATION_FACTORS;
+	const CO2_EMISSIONS = {
+	    electricity: 0.855,
+	    gas: 11.7,
+	    oil: 22.4,
+	};
+	heatingConstants.CO2_EMISSIONS = CO2_EMISSIONS;
+	const SYSTEM_EFFICIENCY = {
+	    "heat-pump": { heating: 3.2, cooling: 16 },
+	    "electric": { heating: 1.0, cooling: 0 },
+	    "gas": { heating: 0.85, cooling: 0 },
+	    "oil": { heating: 0.8, cooling: 0 },
+	    "split-ac": { heating: 2.8, cooling: 14 },
+	    "central-ac": { heating: 0, cooling: 13 },
+	};
+	heatingConstants.SYSTEM_EFFICIENCY = SYSTEM_EFFICIENCY;
+	const DISTRIBUTION_EFFICIENCY = {
+	    "central-air": 0.85,
+	    "radiators": 0.9,
+	    "radiant-floor": 0.95,
+	    "radiant-ceiling": 0.92,
+	};
+	heatingConstants.DISTRIBUTION_EFFICIENCY = DISTRIBUTION_EFFICIENCY;
+	const EQUIPMENT_COSTS = {
+	    "heat-pump": { base: 8000, perSqFt: 3 },
+	    "electric": { base: 2000, perSqFt: 1 },
+	    "gas": { base: 4000, perSqFt: 2 },
+	    "oil": { base: 5000, perSqFt: 2.5 },
+	    "split-ac": { base: 6000, perSqFt: 2.5 },
+	    "central-ac": { base: 7000, perSqFt: 3 },
+	};
+	heatingConstants.EQUIPMENT_COSTS = EQUIPMENT_COSTS;
+	const DISTRIBUTION_COSTS = {
+	    "central-air": { base: 3000, perSqFt: 2 },
+	    "radiators": { base: 4000, perSqFt: 3 },
+	    "radiant-floor": { base: 8000, perSqFt: 6 },
+	    "radiant-ceiling": { base: 6000, perSqFt: 4 },
+	};
+	heatingConstants.DISTRIBUTION_COSTS = DISTRIBUTION_COSTS;
+	
+	return heatingConstants;
+}
+
+var hasRequiredHeatingSimulation;
+
+function requireHeatingSimulation () {
+	if (hasRequiredHeatingSimulation) return heatingSimulation;
+	hasRequiredHeatingSimulation = 1;
+	"use strict";
+	Object.defineProperty(heatingSimulation, "__esModule", { value: true });
+	heatingSimulation.houseSchema = heatingSimulation.locationSchema = void 0;
+	heatingSimulation.calculateHeatingSystemComparison = calculateHeatingSystemComparison;
+	heatingSimulation.getDefaultUtilityRates = getDefaultUtilityRates;
+	const heatingConstants_1 = /*@__PURE__*/ requireHeatingConstants();
+	function calculateHeatLoss(house, location) {
+	    const climateData = heatingConstants_1.CLIMATE_DATA["Zone 1"];
+	    const baseHeatLoss = house.size * 30;
+	    const insulationFactor = heatingConstants_1.INSULATION_FACTORS[house.insulationLevel];
+	    const sharedWallFactor = 1;
+	    return baseHeatLoss * insulationFactor * sharedWallFactor *
+	        ((climateData === null || climateData === void 0 ? void 0 : climateData.heatingDegreeHours) || 3000) / 3000;
+	}
+	function calculateCoolingLoad(house, location) {
+	    const climateData = heatingConstants_1.CLIMATE_DATA["Zone 1"];
+	    const baseCoolingLoad = house.size * 25;
+	    const insulationFactor = heatingConstants_1.INSULATION_FACTORS[house.insulationLevel];
+	    return baseCoolingLoad * insulationFactor *
+	        ((climateData === null || climateData === void 0 ? void 0 : climateData.coolingDegreeHours) || 1500) / 1500;
+	}
+	function calculateEnergyConsumption(heatLoss, coolingLoad, system, hours) {
+	    const systemEff = heatingConstants_1.SYSTEM_EFFICIENCY[system.type];
+	    const distEff = heatingConstants_1.DISTRIBUTION_EFFICIENCY[system.distribution];
+	    const heatingEnergy = (heatLoss * hours) /
+	        (systemEff.heating * distEff * 3412);
+	    const coolingEnergy = (coolingLoad * hours) /
+	        (systemEff.cooling * distEff * 3412);
+	    return { heating: heatingEnergy, cooling: coolingEnergy };
+	}
+	function calculateCosts(energy, system, rates) {
+	    let cost = 0;
+	    if (system.type === "heat-pump" || system.type === "electric" ||
+	        system.type === "split-ac" || system.type === "central-ac") {
+	        cost = (energy.heating + energy.cooling) * rates.electricity;
+	    }
+	    else if (system.type === "gas") {
+	        cost = (energy.heating * 3412 / 100000) * rates.gas +
+	            energy.cooling * rates.electricity;
+	    }
+	    else if (system.type === "oil") {
+	        cost = (energy.heating * 3412 / 138690) * rates.oil +
+	            energy.cooling * rates.electricity;
+	    }
+	    return cost;
+	}
+	function calculateCO2Emissions(energy, system) {
+	    let emissions = 0;
+	    if (system.type === "heat-pump" || system.type === "electric" ||
+	        system.type === "split-ac" || system.type === "central-ac") {
+	        emissions = (energy.heating + energy.cooling) *
+	            heatingConstants_1.CO2_EMISSIONS.electricity;
+	    }
+	    else if (system.type === "gas") {
+	        emissions = (energy.heating * 3412 / 100000) * heatingConstants_1.CO2_EMISSIONS.gas +
+	            energy.cooling * heatingConstants_1.CO2_EMISSIONS.electricity;
+	    }
+	    else if (system.type === "oil") {
+	        emissions = (energy.heating * 3412 / 138690) * heatingConstants_1.CO2_EMISSIONS.oil +
+	            energy.cooling * heatingConstants_1.CO2_EMISSIONS.electricity;
+	    }
+	    return emissions;
+	}
+	function calculateSystemCosts(system, house) {
+	    const equipmentCost = heatingConstants_1.EQUIPMENT_COSTS[system.type];
+	    const distributionCost = heatingConstants_1.DISTRIBUTION_COSTS[system.distribution];
+	    const equipment = equipmentCost.base + (equipmentCost.perSqFt * house.size);
+	    const distribution = distributionCost.base +
+	        (distributionCost.perSqFt * house.size);
+	    const installation = (equipment + distribution) * 0.3;
+	    return {
+	        equipment: equipment + distribution,
+	        installation,
+	        total: equipment + distribution + installation,
+	    };
+	}
+	function calculateHeatingSystemComparison(input) {
+	    const heatLoss = calculateHeatLoss(input.house, input.location);
+	    const coolingLoad = calculateCoolingLoad(input.house, input.location);
+	    const operatingHours = 2000;
+	    const currentEnergy = calculateEnergyConsumption(heatLoss, coolingLoad, input.currentSystem, operatingHours);
+	    const currentCost = calculateCosts(currentEnergy, input.currentSystem, input.utilityRates);
+	    const currentCO2 = calculateCO2Emissions(currentEnergy, input.currentSystem);
+	    const proposedEnergy = calculateEnergyConsumption(heatLoss, coolingLoad, input.proposedSystem, operatingHours);
+	    const proposedCost = calculateCosts(proposedEnergy, input.proposedSystem, input.utilityRates);
+	    const proposedCO2 = calculateCO2Emissions(proposedEnergy, input.proposedSystem);
+	    const systemCosts = calculateSystemCosts(input.proposedSystem, input.house);
+	    const totalCurrentEnergy = currentEnergy.heating + currentEnergy.cooling;
+	    const totalProposedEnergy = proposedEnergy.heating + proposedEnergy.cooling;
+	    const energySavings = totalCurrentEnergy - totalProposedEnergy;
+	    const costSavings = currentCost - proposedCost;
+	    const co2Savings = currentCO2 - proposedCO2;
+	    const paybackPeriod = costSavings > 0
+	        ? systemCosts.total / costSavings
+	        : Infinity;
+	    return {
+	        energySavings: {
+	            annual: energySavings,
+	            percentage: (energySavings / totalCurrentEnergy) * 100,
+	        },
+	        co2Savings: {
+	            annual: co2Savings,
+	            percentage: (co2Savings / currentCO2) * 100,
+	        },
+	        costSavings: {
+	            annual: costSavings,
+	            monthlyAverage: costSavings / 12,
+	            percentage: (costSavings / currentCost) * 100,
+	        },
+	        newSystemCosts: {
+	            equipment: systemCosts.equipment,
+	            installation: systemCosts.installation,
+	            total: systemCosts.total,
+	            paybackPeriod,
+	        },
+	        efficiency: {
+	            current: heatingConstants_1.SYSTEM_EFFICIENCY[input.currentSystem.type].heating,
+	            proposed: heatingConstants_1.SYSTEM_EFFICIENCY[input.proposedSystem.type].heating,
+	            improvement: ((heatingConstants_1.SYSTEM_EFFICIENCY[input.proposedSystem.type].heating -
+	                heatingConstants_1.SYSTEM_EFFICIENCY[input.currentSystem.type].heating) /
+	                heatingConstants_1.SYSTEM_EFFICIENCY[input.currentSystem.type].heating) * 100,
+	        },
+	    };
+	}
+	function getDefaultUtilityRates(location) {
+	    const stateRates = {
+	        "CA": { electricity: 0.28, gas: 1.15, oil: 3.20 },
+	        "NY": { electricity: 0.20, gas: 1.05, oil: 3.10 },
+	        "TX": { electricity: 0.12, gas: 0.95, oil: 2.90 },
+	        "FL": { electricity: 0.14, gas: 1.20, oil: 3.00 },
+	    };
+	    return stateRates[location.address] ||
+	        { electricity: 0.16, gas: 1.00, oil: 3.00 };
+	}
+	heatingSimulation.locationSchema = {
+	    city: (value) => value.length > 0 ? null : "City is required",
+	    state: (value) => value.length > 0 ? null : "State is required",
+	    climateZone: (value) => Object.keys(heatingConstants_1.CLIMATE_DATA).includes(value)
+	        ? null
+	        : "Invalid climate zone",
+	};
+	heatingSimulation.houseSchema = {
+	    size: (value) => value > 0 && value < 50000
+	        ? null
+	        : "House size must be between 1 and 50,000 sq ft",
+	    sharedWalls: (value) => value >= 0 && value <= 4
+	        ? null
+	        : "Shared walls must be between 0 and 4",
+	};
+	
+	return heatingSimulation;
+}
+
+var hasRequiredSimulation;
+
+function requireSimulation () {
+	if (hasRequiredSimulation) return simulation$1;
+	hasRequiredSimulation = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (simulation$1 && simulation$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (simulation$1 && simulation$1.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(/*@__PURE__*/ requireSimulation$1(), exports);
+		__exportStar(/*@__PURE__*/ requireTypes(), exports);
+		__exportStar(/*@__PURE__*/ requireHeatingSimulation(), exports);
+		
+	} (simulation$1));
+	return simulation$1;
+}
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist$1;
+	hasRequiredDist = 1;
+	(function (exports) {
+		"use strict";
+		var __createBinding = (dist$1 && dist$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (dist$1 && dist$1.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(/*@__PURE__*/ requireGeometry(), exports);
+		__exportStar(/*@__PURE__*/ requireUtils(), exports);
+		__exportStar(/*@__PURE__*/ requireSimulation(), exports);
+		
+	} (dist$1));
+	return dist$1;
+}
+
+var distExports = /*@__PURE__*/ requireDist();
+
+const OPEN_POLYGON_COLOR = "red"; //"#ffffff";
+const CLOSED_POLYGON_COLOR = "#fcba03";
+const DOTTED_LINE_COLOR = "rgba(0, 0, 0, 0.5)";
+const ROW_SPACING = 1;
+const COLUMN_SPACING = 1;
+const BORDER_INSET = 0;
+const DEFAULT_SUNNINESS = 600;
+const HEAT_PUMP_CONSUMPTION = 46; // kWh per m² per year
+const SOLAR_RADIATION = [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 00:00 - 05:00 - 6
+    0,
+    0.1,
+    0.2, // 8
+    0.4,
+    0.8,
+    1, // 06:00 - 11:00 - 12
+    1,
+    1,
+    1,
+    0.7,
+    0.5,
+    0.3, // 12:00 - 17:00 - 18
+    0.16,
+    0.02,
+    0,
+    0,
+    0,
+    0, // 18:00 - 23:00 - 24
+];
+const CONSUMPTION_PROFILES = {
+    mostly_at_home: [
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.15, // 00:00 - 05:00 - 6
+        0.23,
+        0.26,
+        0.16,
+        0.16,
+        0.15,
+        0.19, // 06:00 - 11:00 - 12
+        0.23,
+        0.24,
+        0.35,
+        0.28,
+        0.275,
+        0.8, // 12:00 - 17:00 - 18
+        0.78,
+        0.74,
+        0.75,
+        0.73,
+        0.26,
+        0.1, // 18:00 - 23:00 - 24
+    ],
+    mostly_away: [
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.15, // 00:00 - 05:00 - 6
+        0.29,
+        0.32,
+        0.25,
+        0.15,
+        0.12,
+        0.14, // 06:00 - 11:00 - 12
+        0.15,
+        0.12,
+        0.16,
+        0.21,
+        0.285,
+        1, // 12:00 - 17:00 - 18
+        0.81,
+        0.77,
+        0.79,
+        0.73,
+        0.26,
+        0.1, // 18:00 - 23:00 - 24
+    ],
+};
+
+export { BORDER_INSET as B, HEAT_PUMP_CONSUMPTION as H, distExports as d, requireDist$1 as r };
+//# sourceMappingURL=constants-hboFofU4.js.map
+
+//# sourceMappingURL=constants-hboFofU4.js.map