additionalData: '@import "src/variables.scss";',

                additionalData: '@import "/src/variables.scss";',

import preprocess from 'svelte-preprocess'
import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';

import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'

    compilerOptions: {
        runes: true,
    },

"use strict";export const SimulationCommunaute = validate10;const schema11 = {"$schema":"http://json-schema.org/draft-07/schema#","$ref":"#/definitions/Grain.SimulationCommunaute","definitions":{"Grain.SimulationCommunaute":{"type":"object","properties":{"puissance":{"type":"number"},"economies":{"type":"number"},"autoconso":{"type":"number"},"autoprod":{"type":"number"},"fraisDivers":{"type":"number"},"prix":{"type":"number"},"apport":{"type":"number"},"interet":{"type":"number"},"echeances":{"type":"number"},"consoMoyenneFoyer":{"type":"number"},"productible":{"type":"number"},"degradation":{"type":"number"},"inflation":{"type":"number"},"ratio":{"type":"number"},"enedis":{"type":"number"},"tarifCRE":{"type":"object","properties":{"limites":{"type":"array","items":{"type":"number"}},"prix":{"type":"array","items":{"type":"number"}},"inflation":{"type":"number"}},"required":["limites","prix","inflation"],"additionalProperties":false},"coutElec":{"type":"number"},"inflationElec":{"type":"number"},"maintenance":{"type":"number"},"turpe":{"type":"number"},"turpeInjection":{"type":"number"},"provisionOnduleurs":{"type":"number"},"assurance":{"type":"number"},"divers":{"type":"number"},"ratioDcAc":{"type":"number"},"dureeAmortissement":{"type":"number"},"tauxIS":{"type":"number"},"tauxDSRA":{"type":"number"}},"required":["puissance","autoconso","autoprod","fraisDivers","prix","apport","interet","echeances","consoMoyenneFoyer","productible","degradation","inflation","ratio","enedis","tarifCRE","coutElec","inflationElec","maintenance","turpe","turpeInjection","provisionOnduleurs","assurance","divers","ratioDcAc","dureeAmortissement","tauxIS","tauxDSRA"],"additionalProperties":false}},"$id":"#/definitions/SimulationCommunaute"};const schema12 = {"type":"object","properties":{"puissance":{"type":"number"},"economies":{"type":"number"},"autoconso":{"type":"number"},"autoprod":{"type":"number"},"fraisDivers":{"type":"number"},"prix":{"type":"number"},"apport":{"type":"number"},"interet":{"type":"number"},"echeances":{"type":"number"},"consoMoyenneFoyer":{"type":"number"},"productible":{"type":"number"},"degradation":{"type":"number"},"inflation":{"type":"number"},"ratio":{"type":"number"},"enedis":{"type":"number"},"tarifCRE":{"type":"object","properties":{"limites":{"type":"array","items":{"type":"number"}},"prix":{"type":"array","items":{"type":"number"}},"inflation":{"type":"number"}},"required":["limites","prix","inflation"],"additionalProperties":false},"coutElec":{"type":"number"},"inflationElec":{"type":"number"},"maintenance":{"type":"number"},"turpe":{"type":"number"},"turpeInjection":{"type":"number"},"provisionOnduleurs":{"type":"number"},"assurance":{"type":"number"},"divers":{"type":"number"},"ratioDcAc":{"type":"number"},"dureeAmortissement":{"type":"number"},"tauxIS":{"type":"number"},"tauxDSRA":{"type":"number"}},"required":["puissance","autoconso","autoprod","fraisDivers","prix","apport","interet","echeances","consoMoyenneFoyer","productible","degradation","inflation","ratio","enedis","tarifCRE","coutElec","inflationElec","maintenance","turpe","turpeInjection","provisionOnduleurs","assurance","divers","ratioDcAc","dureeAmortissement","tauxIS","tauxDSRA"],"additionalProperties":false};const func2 = Object.prototype.hasOwnProperty;function validate10(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){/*# sourceURL="#/definitions/SimulationCommunaute" */;let vErrors = null;let errors = 0;const _errs0 = errors;if(errors === _errs0){if(data && typeof data == "object" && !Array.isArray(data)){let missing0;if((((((((((((((((((((((((((((data.puissance === undefined) && (missing0 = "puissance")) || ((data.autoconso === undefined) && (missing0 = "autoconso"))) || ((data.autoprod === undefined) && (missing0 = "autoprod"))) || ((data.fraisDivers === undefined) && (missing0 = "fraisDivers"))) || ((data.prix === undefined) && (missing0 = "prix"))) || ((data.apport === undefined) && (missing0 = "apport"))) || ((data.interet === undefined) && (missing0 = "interet"))) || ((data.echeances === undefined) && (missing0 = "echeances"))) || ((data.consoMoyenneFoyer === undefined) && (missing0 = "consoMoyenneFoyer"))) || ((data.productible === undefined) && (missing0 = "productible"))) || ((data.degradation === undefined) && (missing0 = "degradation"))) || ((data.inflation === undefined) && (missing0 = "inflation"))) || ((data.ratio === undefined) && (missing0 = "ratio"))) || ((data.enedis === undefined) && (missing0 = "enedis"))) || ((data.tarifCRE === undefined) && (missing0 = "tarifCRE"))) || ((data.coutElec === undefined) && (missing0 = "coutElec"))) || ((data.inflationElec === undefined) && (missing0 = "inflationElec"))) || ((data.maintenance === undefined) && (missing0 = "maintenance"))) || ((data.turpe === undefined) && (missing0 = "turpe"))) || ((data.turpeInjection === undefined) && (missing0 = "turpeInjection"))) || ((data.provisionOnduleurs === undefined) && (missing0 = "provisionOnduleurs"))) || ((data.assurance === undefined) && (missing0 = "assurance"))) || ((data.divers === undefined) && (missing0 = "divers"))) || ((data.ratioDcAc === undefined) && (missing0 = "ratioDcAc"))) || ((data.dureeAmortissement === undefined) && (missing0 = "dureeAmortissement"))) || ((data.tauxIS === undefined) && (missing0 = "tauxIS"))) || ((data.tauxDSRA === undefined) && (missing0 = "tauxDSRA"))){validate10.errors = [{instancePath,schemaPath:"#/definitions/Grain.SimulationCommunaute/required",keyword:"required",params:{missingProperty: missing0},message:"must have required property '"+missing0+"'",schema:schema12.required,parentSchema:schema12,data}];return false;}else {const _errs2 = errors;for(const key0 in data){if(!(func2.call(schema12.properties, key0))){validate10.errors = [{instancePath,schemaPath:"#/definitions/Grain.SimulationCommunaute/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties",schema:false,parentSchema:schema12,data}];return false;break;}}if(_errs2 === errors){if(data.puissance !== undefined){let data0 = data.puissance;const _errs3 = errors;if(!((typeof data0 == "number") && (isFinite(data0)))){validate10.errors = [{instancePath:instancePath+"/puissance",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/puissance/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.puissance.type,parentSchema:schema12.properties.puissance,data:data0}];return false;}var valid1 = _errs3 === errors;}else {var valid1 = true;}if(valid1){if(data.economies !== undefined){let data1 = data.economies;const _errs5 = errors;if(!((typeof data1 == "number") && (isFinite(data1)))){validate10.errors = [{instancePath:instancePath+"/economies",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/economies/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.economies.type,parentSchema:schema12.properties.economies,data:data1}];return false;}var valid1 = _errs5 === errors;}else {var valid1 = true;}if(valid1){if(data.autoconso !== undefined){let data2 = data.autoconso;const _errs7 = errors;if(!((typeof data2 == "number") && (isFinite(data2)))){validate10.errors = [{instancePath:instancePath+"/autoconso",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/autoconso/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.autoconso.type,parentSchema:schema12.properties.autoconso,data:data2}];return false;}var valid1 = _errs7 === errors;}else {var valid1 = true;}if(valid1){if(data.autoprod !== undefined){let data3 = data.autoprod;const _errs9 = errors;if(!((typeof data3 == "number") && (isFinite(data3)))){validate10.errors = [{instancePath:instancePath+"/autoprod",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/autoprod/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.autoprod.type,parentSchema:schema12.properties.autoprod,data:data3}];return false;}var valid1 = _errs9 === errors;}else {var valid1 = true;}if(valid1){if(data.fraisDivers !== undefined){let data4 = data.fraisDivers;const _errs11 = errors;if(!((typeof data4 == "number") && (isFinite(data4)))){validate10.errors = [{instancePath:instancePath+"/fraisDivers",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/fraisDivers/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.fraisDivers.type,parentSchema:schema12.properties.fraisDivers,data:data4}];return false;}var valid1 = _errs11 === errors;}else {var valid1 = true;}if(valid1){if(data.prix !== undefined){let data5 = data.prix;const _errs13 = errors;if(!((typeof data5 == "number") && (isFinite(data5)))){validate10.errors = [{instancePath:instancePath+"/prix",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/prix/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.prix.type,parentSchema:schema12.properties.prix,data:data5}];return false;}var valid1 = _errs13 === errors;}else {var valid1 = true;}if(valid1){if(data.apport !== undefined){let data6 = data.apport;const _errs15 = errors;if(!((typeof data6 == "number") && (isFinite(data6)))){validate10.errors = [{instancePath:instancePath+"/apport",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/apport/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.apport.type,parentSchema:schema12.properties.apport,data:data6}];return false;}var valid1 = _errs15 === errors;}else {var valid1 = true;}if(valid1){if(data.interet !== undefined){let data7 = data.interet;const _errs17 = errors;if(!((typeof data7 == "number") && (isFinite(data7)))){validate10.errors = [{instancePath:instancePath+"/interet",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/interet/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.interet.type,parentSchema:schema12.properties.interet,data:data7}];return false;}var valid1 = _errs17 === errors;}else {var valid1 = true;}if(valid1){if(data.echeances !== undefined){let data8 = data.echeances;const _errs19 = errors;if(!((typeof data8 == "number") && (isFinite(data8)))){validate10.errors = [{instancePath:instancePath+"/echeances",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/echeances/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.echeances.type,parentSchema:schema12.properties.echeances,data:data8}];return false;}var valid1 = _errs19 === errors;}else {var valid1 = true;}if(valid1){if(data.consoMoyenneFoyer !== undefined){let data9 = data.consoMoyenneFoyer;const _errs21 = errors;if(!((typeof data9 == "number") && (isFinite(data9)))){validate10.errors = [{instancePath:instancePath+"/consoMoyenneFoyer",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/consoMoyenneFoyer/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.consoMoyenneFoyer.type,parentSchema:schema12.properties.consoMoyenneFoyer,data:data9}];return false;}var valid1 = _errs21 === errors;}else {var valid1 = true;}if(valid1){if(data.productible !== undefined){let data10 = data.productible;const _errs23 = errors;if(!((typeof data10 == "number") && (isFinite(data10)))){validate10.errors = [{instancePath:instancePath+"/productible",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/productible/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.productible.type,parentSchema:schema12.properties.productible,data:data10}];return false;}var valid1 = _errs23 === errors;}else {var valid1 = true;}if(valid1){if(data.degradation !== undefined){let data11 = data.degradation;const _errs25 = errors;if(!((typeof data11 == "number") && (isFinite(data11)))){validate10.errors = [{instancePath:instancePath+"/degradation",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/degradation/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.degradation.type,parentSchema:schema12.properties.degradation,data:data11}];return false;}var valid1 = _errs25 === errors;}else {var valid1 = true;}if(valid1){if(data.inflation !== undefined){let data12 = data.inflation;const _errs27 = errors;if(!((typeof data12 == "number") && (isFinite(data12)))){validate10.errors = [{instancePath:instancePath+"/inflation",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/inflation/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.inflation.type,parentSchema:schema12.properties.inflation,data:data12}];return false;}var valid1 = _errs27 === errors;}else {var valid1 = true;}if(valid1){if(data.ratio !== undefined){let data13 = data.ratio;const _errs29 = errors;if(!((typeof data13 == "number") && (isFinite(data13)))){validate10.errors = [{instancePath:instancePath+"/ratio",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/ratio/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.ratio.type,parentSchema:schema12.properties.ratio,data:data13}];return false;}var valid1 = _errs29 === errors;}else {var valid1 = true;}if(valid1){if(data.enedis !== undefined){let data14 = data.enedis;const _errs31 = errors;if(!((typeof data14 == "number") && (isFinite(data14)))){validate10.errors = [{instancePath:instancePath+"/enedis",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/enedis/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.enedis.type,parentSchema:schema12.properties.enedis,data:data14}];return false;}var valid1 = _errs31 === errors;}else {var valid1 = true;}if(valid1){if(data.tarifCRE !== undefined){let data15 = data.tarifCRE;const _errs33 = errors;if(errors === _errs33){if(data15 && typeof data15 == "object" && !Array.isArray(data15)){let missing1;if((((data15.limites === undefined) && (missing1 = "limites")) || ((data15.prix === undefined) && (missing1 = "prix"))) || ((data15.inflation === undefined) && (missing1 = "inflation"))){validate10.errors = [{instancePath:instancePath+"/tarifCRE",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/required",keyword:"required",params:{missingProperty: missing1},message:"must have required property '"+missing1+"'",schema:schema12.properties.tarifCRE.required,parentSchema:schema12.properties.tarifCRE,data:data15}];return false;}else {const _errs35 = errors;for(const key1 in data15){if(!(((key1 === "limites") || (key1 === "prix")) || (key1 === "inflation"))){validate10.errors = [{instancePath:instancePath+"/tarifCRE",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties",schema:false,parentSchema:schema12.properties.tarifCRE,data:data15}];return false;break;}}if(_errs35 === errors){if(data15.limites !== undefined){let data16 = data15.limites;const _errs36 = errors;if(errors === _errs36){if(Array.isArray(data16)){var valid3 = true;const len0 = data16.length;for(let i0=0; i0<len0; i0++){let data17 = data16[i0];const _errs38 = errors;if(!((typeof data17 == "number") && (isFinite(data17)))){validate10.errors = [{instancePath:instancePath+"/tarifCRE/limites/" + i0,schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/properties/limites/items/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.tarifCRE.properties.limites.items.type,parentSchema:schema12.properties.tarifCRE.properties.limites.items,data:data17}];return false;}var valid3 = _errs38 === errors;if(!valid3){break;}}}else {validate10.errors = [{instancePath:instancePath+"/tarifCRE/limites",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/properties/limites/type",keyword:"type",params:{type: "array"},message:"must be array",schema:schema12.properties.tarifCRE.properties.limites.type,parentSchema:schema12.properties.tarifCRE.properties.limites,data:data16}];return false;}}var valid2 = _errs36 === errors;}else {var valid2 = true;}if(valid2){if(data15.prix !== undefined){let data18 = data15.prix;const _errs40 = errors;if(errors === _errs40){if(Array.isArray(data18)){var valid4 = true;const len1 = data18.length;for(let i1=0; i1<len1; i1++){let data19 = data18[i1];const _errs42 = errors;if(!((typeof data19 == "number") && (isFinite(data19)))){validate10.errors = [{instancePath:instancePath+"/tarifCRE/prix/" + i1,schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/properties/prix/items/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.tarifCRE.properties.prix.items.type,parentSchema:schema12.properties.tarifCRE.properties.prix.items,data:data19}];return false;}var valid4 = _errs42 === errors;if(!valid4){break;}}}else {validate10.errors = [{instancePath:instancePath+"/tarifCRE/prix",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/properties/prix/type",keyword:"type",params:{type: "array"},message:"must be array",schema:schema12.properties.tarifCRE.properties.prix.type,parentSchema:schema12.properties.tarifCRE.properties.prix,data:data18}];return false;}}var valid2 = _errs40 === errors;}else {var valid2 = true;}if(valid2){if(data15.inflation !== undefined){let data20 = data15.inflation;const _errs44 = errors;if(!((typeof data20 == "number") && (isFinite(data20)))){validate10.errors = [{instancePath:instancePath+"/tarifCRE/inflation",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/properties/inflation/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.tarifCRE.properties.inflation.type,parentSchema:schema12.properties.tarifCRE.properties.inflation,data:data20}];return false;}var valid2 = _errs44 === errors;}else {var valid2 = true;}}}}}}else {validate10.errors = [{instancePath:instancePath+"/tarifCRE",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tarifCRE/type",keyword:"type",params:{type: "object"},message:"must be object",schema:schema12.properties.tarifCRE.type,parentSchema:schema12.properties.tarifCRE,data:data15}];return false;}}var valid1 = _errs33 === errors;}else {var valid1 = true;}if(valid1){if(data.coutElec !== undefined){let data21 = data.coutElec;const _errs46 = errors;if(!((typeof data21 == "number") && (isFinite(data21)))){validate10.errors = [{instancePath:instancePath+"/coutElec",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/coutElec/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.coutElec.type,parentSchema:schema12.properties.coutElec,data:data21}];return false;}var valid1 = _errs46 === errors;}else {var valid1 = true;}if(valid1){if(data.inflationElec !== undefined){let data22 = data.inflationElec;const _errs48 = errors;if(!((typeof data22 == "number") && (isFinite(data22)))){validate10.errors = [{instancePath:instancePath+"/inflationElec",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/inflationElec/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.inflationElec.type,parentSchema:schema12.properties.inflationElec,data:data22}];return false;}var valid1 = _errs48 === errors;}else {var valid1 = true;}if(valid1){if(data.maintenance !== undefined){let data23 = data.maintenance;const _errs50 = errors;if(!((typeof data23 == "number") && (isFinite(data23)))){validate10.errors = [{instancePath:instancePath+"/maintenance",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/maintenance/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.maintenance.type,parentSchema:schema12.properties.maintenance,data:data23}];return false;}var valid1 = _errs50 === errors;}else {var valid1 = true;}if(valid1){if(data.turpe !== undefined){let data24 = data.turpe;const _errs52 = errors;if(!((typeof data24 == "number") && (isFinite(data24)))){validate10.errors = [{instancePath:instancePath+"/turpe",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/turpe/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.turpe.type,parentSchema:schema12.properties.turpe,data:data24}];return false;}var valid1 = _errs52 === errors;}else {var valid1 = true;}if(valid1){if(data.turpeInjection !== undefined){let data25 = data.turpeInjection;const _errs54 = errors;if(!((typeof data25 == "number") && (isFinite(data25)))){validate10.errors = [{instancePath:instancePath+"/turpeInjection",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/turpeInjection/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.turpeInjection.type,parentSchema:schema12.properties.turpeInjection,data:data25}];return false;}var valid1 = _errs54 === errors;}else {var valid1 = true;}if(valid1){if(data.provisionOnduleurs !== undefined){let data26 = data.provisionOnduleurs;const _errs56 = errors;if(!((typeof data26 == "number") && (isFinite(data26)))){validate10.errors = [{instancePath:instancePath+"/provisionOnduleurs",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/provisionOnduleurs/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.provisionOnduleurs.type,parentSchema:schema12.properties.provisionOnduleurs,data:data26}];return false;}var valid1 = _errs56 === errors;}else {var valid1 = true;}if(valid1){if(data.assurance !== undefined){let data27 = data.assurance;const _errs58 = errors;if(!((typeof data27 == "number") && (isFinite(data27)))){validate10.errors = [{instancePath:instancePath+"/assurance",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/assurance/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.assurance.type,parentSchema:schema12.properties.assurance,data:data27}];return false;}var valid1 = _errs58 === errors;}else {var valid1 = true;}if(valid1){if(data.divers !== undefined){let data28 = data.divers;const _errs60 = errors;if(!((typeof data28 == "number") && (isFinite(data28)))){validate10.errors = [{instancePath:instancePath+"/divers",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/divers/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.divers.type,parentSchema:schema12.properties.divers,data:data28}];return false;}var valid1 = _errs60 === errors;}else {var valid1 = true;}if(valid1){if(data.ratioDcAc !== undefined){let data29 = data.ratioDcAc;const _errs62 = errors;if(!((typeof data29 == "number") && (isFinite(data29)))){validate10.errors = [{instancePath:instancePath+"/ratioDcAc",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/ratioDcAc/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.ratioDcAc.type,parentSchema:schema12.properties.ratioDcAc,data:data29}];return false;}var valid1 = _errs62 === errors;}else {var valid1 = true;}if(valid1){if(data.dureeAmortissement !== undefined){let data30 = data.dureeAmortissement;const _errs64 = errors;if(!((typeof data30 == "number") && (isFinite(data30)))){validate10.errors = [{instancePath:instancePath+"/dureeAmortissement",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/dureeAmortissement/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.dureeAmortissement.type,parentSchema:schema12.properties.dureeAmortissement,data:data30}];return false;}var valid1 = _errs64 === errors;}else {var valid1 = true;}if(valid1){if(data.tauxIS !== undefined){let data31 = data.tauxIS;const _errs66 = errors;if(!((typeof data31 == "number") && (isFinite(data31)))){validate10.errors = [{instancePath:instancePath+"/tauxIS",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tauxIS/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.tauxIS.type,parentSchema:schema12.properties.tauxIS,data:data31}];return false;}var valid1 = _errs66 === errors;}else {var valid1 = true;}if(valid1){if(data.tauxDSRA !== undefined){let data32 = data.tauxDSRA;const _errs68 = errors;if(!((typeof data32 == "number") && (isFinite(data32)))){validate10.errors = [{instancePath:instancePath+"/tauxDSRA",schemaPath:"#/definitions/Grain.SimulationCommunaute/properties/tauxDSRA/type",keyword:"type",params:{type: "number"},message:"must be number",schema:schema12.properties.tauxDSRA.type,parentSchema:schema12.properties.tauxDSRA,data:data32}];return false;}var valid1 = _errs68 === errors;}else {var valid1 = true;}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}else {validate10.errors = [{instancePath,schemaPath:"#/definitions/Grain.SimulationCommunaute/type",keyword:"type",params:{type: "object"},message:"must be object",schema:schema12.type,parentSchema:schema12,data}];return false;}}validate10.errors = vErrors;return errors === 0;}

<script lang="ts">
</script>
<div class="chart-container">
        <!-- Dots (if enabled) -->
        {#if showDots && !dotInfo}
            {#each I as i}
                    <circle
                        cx={xScale(xVals[i])}
                        cy={yScale(yVals[i])}
                        stroke={colors[colorVals[i]]}
                </g>
            {/each}
        {/if}
        <!-- Chart lines -->
        {#each lines as subsetLine, i}
                {#if dotInfo && false}
                {:else}
                {/if}
            </g>
        {/each}
        <!-- Y-axis and horizontal grid lines -->
            {#each yTicks as tick}
                <g class="tick" transform="translate(0, {yScale(tick)})">
                    {#if horizontalGrid}
                    {/if}
                    <text x="-10" y="5">{tick + yFormat}</text>
                </g>
            {/each}
            <text text-anchor="middle" x="0" y={marginTop - 10}>{yLabel}</text>
        </g>
        <!-- X-axis and vertical grid lines -->
            {#each xTicks as tick, i}
                <g class="tick" transform="translate({xScale(tick)}, 0)">
                    {#if verticalGrid}
                    {/if}
                </g>
            {/each}
        </g>
        {#each pointsScaled as point, i}
            <path
                stroke="none"
                fill-opacity="0"
                class="voronoi-cell"
                d={voronoiGrid.renderCell(i)}
        {/each}
    </svg>
</div>
<!-- Tooltip -->
{#if dotInfo}
        {points[dotInfo[1]].x}: {points[dotInfo[1]].y.toFixed(2)}{yFormat}
    </div>
{/if}
<style>
</style>
    .tooltip {
        border-radius: 5px;
        padding: 5px;
        box-shadow: rgba(0, 0, 0, 0.4) 0px 2px 4px,
            rgba(0, 0, 0, 0.3) 0px 7px 13px -3px,
            rgba(0, 0, 0, 0.2) 0px -3px 0px inset;
        opacity: 1;
    }
    @media (prefers-color-scheme: dark) {
        .y-axis text {
            fill: white;
        }
        .x-axis text {
            fill: white;
        }
        .tick-start {
            stroke: white;
        }
        .tick-grid {
            stroke: white;
        }
        .tick text {
            fill: white;
        }
        .domain {
            stroke: white;
        }
    }
    .y-axis .tick text {
        text-anchor: end !important;
    }
    .chart-container {
        justify-content: center;
        align-items: center;
        margin-top: 50px;
        margin-left: 8 0px;
    }
    svg {
        max-width: 100%;
        height: auto;
        height: 'intrinsic';
        margin: auto;
    }
    path {
        fill: 'green';
    }
    .y-axis {
        font-size: '10px';
        font-family: sans-serif;
        text-anchor: 'end';
    }
    .x-axis {
        font-size: '10px';
        font-family: sans-serif;
        text-anchor: 'end';
    }
    .tick text {
        font-size: 80%;
        fill: white !important;
    }
    .tick {
        opacity: 1;
    }
    .tick-start {
        stroke: black;
        stroke-opacity: 1;
    }
    .tick-grid {
        stroke: black;
        stroke-opacity: 0.2;
        font-size: '11px';
        color: black;
    }
    .tick text {
        fill: black;
    }
    <div
        class="tooltip"
        style="position:absolute; left:{dotInfo[2].pageX +
            12}px; top:{dotInfo[2].pageY +
            12}px; pointer-events:none; background-color:{tooltipBackground}; color:{tooltipTextColor}">
                on:mouseover={(e) => (dotInfo = [point, i, e])}
                on:focus={(e) => (dotInfo = [point, i, e])} />
            <text x={width - marginLeft - marginRight - 40} y={marginBottom}
                >{xLabel}</text>
                    <text font-size="8px" x={-marginLeft / 4} y="20"
                        >{xTicksFormatted[i] + xFormat}</text>
                        <line
                            class="tick-grid"
                            y2={-height + insetTop + marginTop} />
                    <line class="tick-start" stroke="black" y2="6" />
        <g
            class="x-axis"
            transform="translate(0,{height - marginBottom - insetBottom})"
            pointer-events="none">
            <path
                class="domain"
                stroke="black"
                d="M{marginLeft},0.5 H{width - marginRight}" />
                        <line
                            class="tick-grid"
                            x1={insetLeft}
                            x2={width - marginLeft - marginRight} />
                    <line
                        class="tick-start"
                        x1={insetLeft - 6}
                        x2={insetLeft} />
        <g
            class="y-axis"
            transform="translate({marginLeft}, 0)"
            pointer-events="none">
            <path
                class="domain"
                stroke="black"
                d="M{insetLeft}, {marginTop} V{height - marginBottom + 6}" />
                    <path
                        class="line"
                        fill="none"
                        stroke={colors[i]}
                        d={subsetLine}
                        stroke-opacity={strokeOpacity[i]}
                        stroke-width={strokeWidth}
                        stroke-linecap={strokeLinecap}
                        stroke-linejoin={strokeLinejoin} />
                    <path
                        class="line"
                        fill="none"
                        stroke-opacity={points[dotInfo[1]].color === i
                            ? '1'
                            : '0.1'}
                        stroke={colors[i]}
                        d={subsetLine}
                        stroke-width={strokeWidth}
                        stroke-linecap={strokeLinecap}
                        stroke-linejoin={strokeLinejoin} />
                    <circle
                        cx={xScale(points[dotInfo[1]].x)}
                        cy={yScale(points[dotInfo[1]].y)}
                        {r}
                        stroke={colors[points[dotInfo[1]].color]}
                        fill={dotsFilled} />
            <g class="chartlines" pointer-events="none">
                        fill={dotsFilled ? colors[colorVals[i]] : 'none'} />
                        {r}
                <g class="dot" pointer-events="none">
    <svg
        {width}
        {height}
        viewBox="0 0 {width} {height}"
        cursor="crosshair"
        on:mouseout={() => (dotInfo = null)}
        on:blur={() => (dotInfo = null)}>
        xTicks = xScale.ticks(xScalefactor)
        xTicksFormatted = xTicks.map((el) => el)
        yTicks = niceY.ticks(yScalefactor)
    }
        pointsScaled = points.map((el) => [
            xScale(el.x),
            yScale(el.y),
            el.color,
        ])
        delaunayGrid = Delaunay.from(pointsScaled)
        voronoiGrid = delaunayGrid.voronoi([0, 0, width, height])
        lines = []
        colors.forEach((_color, j) => {
            const filteredI = I.filter((_el, i) => colorVals[i] === j)
            lines.push(chartLine(filteredI))
        })
        console.log('lines', lines)
        chartLine = line()
            .defined((i) => cleanData[i])
            .curve(curve)
            .x((i) => xScale(xVals[i]))
            .y((i) => yScale(yVals[i]))
        xDomain = [xVals[0], xVals[xVals.length - 1]]
        yDomain = [Math.min(...yVals), Math.max(...yVals)]
        xScale = xType(xDomain, xRange)
        yScale = yType(yDomain, yRange)
        niceY = scaleLinear()
            .domain([Math.min(...yVals), Math.max(...yVals)])
            .nice()
        I = range(xVals.length)
        gaps = (_d, i) => !isNaN(xVals[i]) && !isNaN(yVals[i])
        cleanData = points.map(gaps)
    $: {
        // For a single set of data
        xVals = []
        yVals = []
        if (!('data' in data[0])) {
            x = Object.keys(data[0])[0]
            y = Object.keys(data[0])[1]
            xVals = data.map((el: Record<string, any>) => el[x])
            yVals = data.map((el: Record<string, any>) => el[y])
            colorVals = data.map((_) => 0)
            points = data.map((el) => ({
                x: el[x],
                y: el[y],
                color: 0,
            }))
        }
        // For data with subsets (NOTE: expects 'id' and 'data' keys)
        else {
            x = Object.keys(data[0]?.data[0])[0]
            y = Object.keys(data[0]?.data[0])[1]
            data.forEach((subset, i) => {
                subset.data.forEach((coordinate) => {
                    xVals.push(coordinate[x])
                    yVals.push(coordinate[y])
                    colorVals.push(i)
                    points.push({
                        x: coordinate[x],
                        y: coordinate[y],
                        color: i,
                    })
                })
                subsets.push(subset.id)
            })
        }
    let I,
        xScale,
        gaps,
        cleanData,
        xDomain,
        yDomain,
        yScale,
        niceY,
        chartLine,
        pointsScaled,
        delaunayGrid,
        voronoiGrid,
        xTicks,
        xTicksFormatted,
        yTicks
    let x: string,
        y: string,
        dotInfo,
        lines,
        xVals = [],
        yVals = [],
        points = [],
        subsets = [],
        colorVals = []
    const marginTop = 30 // the top margin, in pixels
    const marginRight = 30 // the right margin, in pixels
    const marginBottom = 30 // the bottom margin, in pixels
    const marginLeft = 100 // the left margin, in pixels
    const inset = 0 // inset the default range, in pixels
    const width = 600 // the outer width of the chart, in pixels
    const height = 400 // the outer height of the chart, in pixels
    const xLabel = '' // a label for the y-axis
    const yLabel = 'Résultat net' // a label for the y-axis
    const xFormat = '' // a format specifier string for the y-axis
    const yFormat = '€' // a format specifier string for the y-axis
    const horizontalGrid = true // show horizontal grid lines
    const verticalGrid = true // show vertical grid lines
    const colors = ['#b81111', '#ffbf00'] // fill color for dots && number of colors in fill array MUST match number of subsets in data
    const showDots = false // whether dots should be displayed
    const dotsFilled = true // whether dots should be filled or outlined
    const r = 0 // (fixed) radius of dots, in pixels
    const strokeWidth = 1 // stroke width of line, in pixels
    const strokeOpacity = [1] // stroke opacity of line
    const tooltipBackground = 'white' // background color of tooltip
    const tooltipTextColor = 'black' // text color of tooltip
    const strokeLinecap = 'round' // stroke line cap of the line
    const strokeLinejoin = 'round' // stroke line join of the line
    const xScalefactor = width / 180 //y-axis number of values
    const yScalefactor = height / 40 //y-axis number of values
    const curve = curveLinear // method of interpolation between points
    const xType = scaleLinear // type of x-scale
    const insetTop = 50 // inset from top
    const insetRight = inset // inset from right
    const insetBottom = inset // inset fro bottom
    const insetLeft = inset // inset from left
    const xRange = [marginLeft + insetLeft, width - marginRight - insetRight] // [left, right]
    const yType = scaleLinear // type of y-scale
    const yRange = [height - marginBottom - insetBottom, marginTop + insetTop] // [bottom, top]
    export let data
    import { line, curveLinear, Delaunay, range, scaleLinear } from 'd3'
    //@ts-nocheck

    export let pvgis_loading = false
    let prm_loading = false
    let initialised = false
    let puissance = 0
    let communaute: null | (Grain.Communaute & { isMoving?: boolean }) = null
    let Plotly: any
    let erreur = ''
    function addProfil(_ev: Event) {
        const prt = Object.keys(profils_)
        data.profils.push({ type: prt[0], conso: 0 })
        data.profils = data.profils
    }
    async function delProfil(i: number) {
        data.profils.splice(i, 1)
        data.profils = data.profils
        await updatePlot(puissance, communaute)
    }
    const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
    var lastRequest = performance.now()
    async function refresh(event: SubmitEvent) {
        event.preventDefault()
        if (data.prms) {
            prm_loading = true
            await tick()
            for(let i = 0; i < data.prms.length; i++) {
                var file = document.getElementById(`releve-${i}`) as HTMLInputElement | null;
                if (file?.files?.length) {
                    var reader = new FileReader();
                    reader.readAsText(file.files[0], "UTF-8");
                    let r: string | undefined = await new Promise((resolve) => {
                        reader.onload = function (evt) {
                            console.log(typeof (evt.target?.result))
                            let result = evt.target?.result?.toString()
                            if(result) {
                                resolve(result)
                            } else {
                                resolve(undefined)
                            }
                        }
                    })
                    data.prms[i].releve = r
                }
                let siret = document.getElementById(`siret-${i}`) as HTMLInputElement | null;
                if(siret?.value) {
                    let now = performance.now();
                    // Rate-limiting: pas plus de 7 requêtes par seconde.
                    if(now - lastRequest < 150) {
                        await sleep(150 - (now - lastRequest))
                    }
                    lastRequest = now
                    const resp = await fetch(
                        `https://recherche-entreprises.api.gouv.fr/search?q=${siret.value}`
                    )
                    if(resp.status == 200) {
                        type Ent = {
                            results: {
                                dirigeants: {
                                    nom: string,
                                    prenoms: string,
                                }[],
                                matching_etablissements: {
                                    libelle_voie: string,
                                    commune: string,
                                }[]
                            }[]
                        }
                        let ent: Ent = await resp.json()
                        console.log(ent.results[0].matching_etablissements[0].commune)
                        if(ent.results.length) {
                            data.prms[i].nom = ent.results[0].dirigeants[0].nom
                            data.prms[i].prenom = ent.results[0].dirigeants[0].prenoms
                            data.prms[i].codeinsee = ent.results[0].matching_etablissements[0].commune
                            console.log(data.prms[i])
                        }
                    }
                }
            }
            console.log(data.prms);
            const resp = await fetch(
                `${server}/api/grain/projet/${data.id || 'nouveau'}/prms`,
                {
                    method: 'POST',
                    body: JSON.stringify(data.prms),
                }
            )
            if (resp.ok) {
                annee = await resp.json()
            }
            prm_loading = false
            await tick()
        } else {
            erreur = 'La liste des PRMs est vide'
        }
        await updatePlot(puissance, communaute)
    }
</div>
<style>
    input::-webkit-outer-spin-button,
    input::-webkit-inner-spin-button {
        -webkit-appearance: none;
        margin: 0;
    }
    input[type=number] {
        appearance: none;
        -moz-appearance:textfield; /* Firefox */
    }
</style>
        var dataProd = [
            {
                values: [Math.round(auto), Math.round(totalProd - auto)],
                labels: ['Autoconsommé', 'Surplus'],
                marker: { colors: ['#ffbf00dd', '#b81111dd'] },
                type: 'pie',
                sort: false,
                hole: 0.5,
            },
        ]
        var dataConso = [
            {
                values: [Math.round(auto), Math.round(totalConso - auto)],
                labels: ['Autoproduit', 'Fournisseur'],
                marker: { colors: ['#ffbf00dd', '#b81111dd'] },
                type: 'pie',
                sort: false,
                hole: 0.5,
            },
        ]
<div class="tab-content" id="simuTabContent">
    <div
        class="tab-pane fade active show p-3"
        id="simu-tab-pane"
        role="tabpanel"
        aria-labelledby="simu-tab"
        tabindex="0">
        <h3 class="my-3 fs-1 fw-bold">Production… <span class="text-primary">Consommation</span></h3>
        <form method="POST" action="/api/grain" id="pdl" on:submit={refresh} />
        {#if erreur}
            <div
                id="erreur"
                class="alert alert-danger fade d-flex"
                class:show={erreur}
                role="alert">
                {erreur}
                <button
                    type="button"
                    class="btn-close"
                    style="padding:20px;margin:-16px -16px -16px auto"
                    on:click={() => (erreur = '')}
                    aria-label="Close" />
            </div>
        {/if}
        <h2 class="my-5">Profils de consommation</h2>
        {#if data.profils.length}
            {#if $expert}
                <div>Vous êtes en mode expert. Dans ce mode, vous avez un accès direct à tous les profils utilisés par les opérateurs du réseau pour simuler les consommations. Voir <a href="https://www.enedis.fr/responsable-dequilibre-profilage-et-profils">la documentation</a>.</div>
            {/if}
            <table class="table">
                <thead
                ><tr><th /><th>Profil</th><th>Consommation annuelle (kWh)</th><th /></tr
                                                                                    ></thead>
                <tbody>
                    {#each data.profils as pr, i}
                        <tr>
                            <td class="px-3 align-middle">Profil</td>
                            <td>
                                <select
                                    class="form-select"
                                    bind:value={pr.type}
                                    on:change={(_ev) =>
                                                  updatePlot(
                                                      puissance,
                                                      communaute,
                                                  )}>
                                    {#each Object.entries(profils_) as [p, _]}
                                        <option value={p}>{p}</option>
                                    {/each}
                                </select>
                            </td>
                            <td>
                                <input
                                    type="number"
                                    class="form-control"
                                    placeholder="Abonnement (kW)"
                                    min="0"
                                    step="500"
                                    bind:value={pr.conso}
                                    on:change={(_ev) =>
                                                  updatePlot(
                                                      puissance,
                                                      communaute,
                                                  )} />
                            </td>
                            <td style="width:1%;white-space:nowrap;text-align:center">
                                <button
                                    class="btn btn-link"
                                    on:click={(_ev) => delProfil(i)}
                                    ><i class="bi bi-x-circle text-primary" /></button>
                            </td>
                        </tr>
                    {/each}
                </tbody>
            </table>
        {/if}
        <div class="text-center">
            <button class="btn btn-primary" on:click={addProfil}
            ><i class="bi bi-plus-circle" />&nbsp;Ajouter un profil</button>
        </div>
        if(totalProd && totalConso) {
            plotStyle = 'min-height:450px'
            Plotly.react(
                'autoProd',
                dataProd,
                {
                    title: "Autoconsommation sur l'année",
                    font: {
                        color: darkMode ? '#fff' : '#000',
                    },
                    plot_bgcolor: '#fff0',
                    paper_bgcolor: '#fff0',
                    autosize: true,
                    automargin: true,
                    legend: {
                        orientation: 'h',
                    },
                },
                { responsive: true }
            )
            Plotly.react(
                'autoConso',
                dataConso,
                {
                    title: "Autoproduction sur l'année",
                    font: {
                        color: darkMode ? '#fff' : '#000',
                    },
                    plot_bgcolor: '#fff0',
                    paper_bgcolor: '#fff0',
                    autosize: true,
                    automargin: true,
                    legend: {
                        orientation: 'h',
                    },
                },
                { responsive: true }
            )
        } else {
            plotStyle = ''
        }
    }

    import Simulation from './Simulation.svelte'
    const data = $props()

        <h2 class="my-5">Relevés de compteurs</h2>
        {#if data.active && data.id && data.id != 'nouveau'}
            <div class="mb-5">Vous pouvez ajouter des compteurs d'entreprises ou d'associations par leur numéro de compteur et leur numéro de SIRET.
            </div>
            {#if data.prms.length}
                {#each data.prms as prm, i}
                    <div class="row my-2">
                        <div class="col-3 d-flex align-middle">
                            <label class="ms-auto form-label" for="prm-{i}">PRM<button
                                                                                   type="button"
                                                                                   class="btn btn-link align-baseline p-0 ms-2"
                                                                                   data-bs-toggle="popover"
                                                                                   data-bs-trigger="hover focus"
                                                                                   data-bs-content="Un PRM, aussi appelé PDL, est l'identifiant d'un compteur électrique. On peut le trouver sur les factures d'électricité, ou en appuyant sur le bouton + du compteur Linky."><i class="bi bi-question-circle" /></button>
                            </label>
                        </div>
                        <div class="col d-flex align-items-center">
                            <input
                                class="form-control form-control-sm"
                                id="prm-{i}"
                                bind:value={prm.prm}
                                on:keydown={(e) => (e.key == 'ArrowUp' || e.key == 'ArrowDown') && e.preventDefault() }
                                type="number" />
                        </div>
                        <div class="col col-auto d-flex align-items-center">
                            <button
                                class="btn btn-outline-primary btn-sm"
                                on:click={(e) => { e.preventDefault(); data.prms.splice(i, 1); data.prms = data.prms; }}
                                ><i class="bi bi-trash"/></button>
                        </div>
                    </div>
                    <div class="row my-2">
                        <div class="col-3 d-flex align-middle">
                            <label class="ms-auto form-label" for="prm-{i}">Relevé au format CSV</label>
                        </div>
                        <div class="col d-flex align-items-center">
                            <input
                                class="form-control form-control-sm"
                                id="releve-{i}"
                                type="file" />
                            {#if prm.releve?.length}
                                <i class="ms-3 bi bi-check-circle"/>
                            {/if}
                        </div>
                    </div>
                    <div class="row my-2">
                        <div class="col-9 ms-auto">
                            <input type="radio" class="btn-check" id="particulier" value={false} bind:group={prm.pro}>
                            <label class="btn btn-sm" for="particulier">Particulier</label>

                            <input type="radio" class="btn-check" id="pro" value={true} bind:group={prm.pro}>
                            <label class="btn btn-sm" for="pro">Professionnel</label>
                        </div>
                    </div>
                    {#if prm.pro}
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="siret-{i}">SIRET du titulaire du compteur</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="siret-{i}"
                                    bind:value={prm.siret} />
                            </div>
                        </div>
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="prenom-{i}">Prénom du titulaire du compteur</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="prenom-{i}"
                                    bind:value={prm.prenom}
                                    />
                            </div>
                        </div>
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="nom-{i}">Nom du titulaire du compteur</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="nom-{i}"
                                    bind:value={prm.nom}
                                    />
                            </div>
                        </div>
                    {:else}
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="prenom-{i}">Prénom du titulaire du compteur</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="prenom-{i}"
                                    bind:value={prm.prenom} />
                            </div>
                        </div>
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="nom-{i}">Nom du titulaire du compteur</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="nom-{i}"
                                    bind:value={prm.nom} />
                            </div>
                        </div>
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="numerorue-{i}">Numéro et rue</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="numerorue-{i}"
                                    bind:value={prm.numerorue} />
                            </div>
                        </div>
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="codepostal-{i}">Code INSEE de la commune</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="codepostal-{i}"
                                    bind:value={prm.codeinsee} />
                            </div>
                        </div>
                        <div class="row my-2">
                            <div class="col-3 d-flex text-end align-items-center">
                                <label class="ms-auto form-label" for="serie-{i}">Numéro de série</label>
                            </div>
                            <div class="col-9 d-flex align-items-center">
                                <input
                                    class="form-control form-control-sm"
                                    id="serie-{i}"
                                    bind:value={prm.serie} />
                            </div>
                        </div>
                    {/if}
                    <div class="my-3 form-check d-flex">
                        <input
                            class="form-check-input ms-auto me-2"
                            type="checkbox"
                            id="consentement-{i}"
                            bind:checked={prm.consentement} />
                        <label class="form-check-label me-auto" for="consentement-{i}">Cet abonné consent à ce que j'accède à ses données.</label>
                    </div>
                    <hr class="my-4" />
                {/each}
            <div class="my-3">
                Ce service ne consulte la courbe de charge du compteur communiquant qu'une seule fois, et ce consentement expire dès que ces données pour l'année écoulée sont récupérées. Les données collectées depuis les compteurs communiquants sont stockées temporairement sur nos serveurs pour des raisons de performance, ne sont utilisées que pour afficher cette page et produire le rapport, et ne sont jamais conservées plus de 30 jours.
            </div>
            <div class="my-3">
                Les données envoyées via un fichier sont conservées jusqu'à ce que vous supprimiez ce projet.
            </div>
            {/if}
            <div class="d-flex justify-content-center">
                <button class="mx-2 btn btn-primary" on:click={addPrm}><i class="bi bi-plus-circle" />&nbsp;Ajouter un compteur</button>
                {#if data.prms.length}
                    <button
                        disabled={!!data.prms.find((p) => !p.releve?.length && !p.consentement)}
                        class="mx-2 btn btn-primary"
                        form="pdl">Mettre à jour</button>
                    <div
                        class="mx-2 spinner-border text-primary"
                        class:d-none={!prm_loading} />
                {/if}
            </div>
        {:else if data.active}
            <div class="my-3">
                Sauvegardez ce projet pour avoir accès aux relevés de compteurs détaillés.
            </div>
        {:else}
            <div class="my-3">
                Vous devez être abonné pour avoir accès aux relevés de compteurs détaillés.
            </div>
        {/if}
        <h2 class="mt-5">Simulation</h2>
        <table class="table table-bordered d-inline-block">
            <tbody>
                <tr><td>Production totale:</td><td>{Math.round(totalProd)}kWh</td></tr>
                <tr
                ><td>Consommation totale:</td><td>{Math.round(totalConso)}kWh</td
                                                                             ></tr>
            </tbody>
        </table>
        {#if pvgis_loading}
            <div class="my-3 d-flex align-items-center text-primary">
                <div class="spinner-border text-primary me-3" />
                Chargement de la production solaire
            </div>
        {/if}
        <div class="my-3">
            <div class="mx-auto" style="min-height:450px" id="plot" />
        </div>
        <div class="row">
            <div class="col-12 col-sm-6 p-0" style={plotStyle} id="autoProd" />
            <div class="col-12 col-sm-6 p-0" style={plotStyle} id="autoConso" />
        </div>
    </div>
    let auto = 0
    let totalProd = 0
    let totalConso = 0
    let somme: Sample = {
        hourly: {
            x: [],
            y: [],
        },
        daily: {
            x: [],
            y: [],
        },
        weekly: {
            x: [],
            y: [],
        },
        x: [],
        y: [],
        type: 'bar',
        line: {
            color: '#b81111',
            width: 1,
        },
        marker: {
            color: '#b81111',
            width: 1,
        },
        name: 'Consommation totale',
        bucket: 1,
    }
    async function updatePv(
        puissance: number,
        communaute: (Grain.Communaute&{isMoving?: boolean}) | null,
    ) {
        if(communaute?.isMoving) {
            return pvgis
        }
        pvgis_loading = true
        await calcul.updatePv(puissance, communaute, pvgis, soleil, base)
        pvgis_loading = false
        await tick()
    }
    async function updatePlot(
        puissance: number,
        communaute: (Grain.Communaute & { isMoving?: boolean }) | null,
    ) {
        console.log("isMoving", communaute?.isMoving)
        if(communaute?.isMoving) {
            return
        }
        if (!browser) {
            return
        }
        await updatePv(puissance, communaute)
        console.log("updated")
        prm_loading = true;
        let auto_ = await calcul.updatePlot(
            assets,
            annee,
            data.profils,
            profils_,
            somme,
            soleil,
        )
        prm_loading = false;
        auto = auto_.auto
        totalProd = auto_.totalProd
        totalConso = auto_.totalConso
        console.log("updated auto", auto, totalProd, totalConso)
        if (!Plotly)
            //@ts-ignore
            Plotly = await import('plotly.js-dist')
        redraw()
    }
    let has_plot = { has_plot: false };
    let layout = {};
    function relayout_(event: any) {
        console.log('relayout_')
        const plot = document.getElementById('plot')!
        relayout(event, plot, Plotly, layout, has_plot, get(soleil), somme)
    }
    function redraw() {
        console.log("redraw")
        const plot = document.getElementById('plot')
        if (!plot) return
        let soleil_ = get(soleil)
        chooseScale(soleil_)
        chooseScale(somme)
        let unite: string
        if (soleil_.bucket == 24) {
            unite = 'kWh/jour'
        } else if (soleil_.bucket == 24 * 7) {
            unite = 'kWh/semaine'
        } else {
            unite = 'kWh'
        }
        layout = {
            title: 'Autoconsommation',
            autosize: true,
            automargin: true,
            plot_bgcolor: '#fff0',
            paper_bgcolor: '#fff0',
            font: {
                color: darkMode ? '#fff' : '#000',
            },
            xaxis: {
                gridcolor: darkMode ? '#444' : '#bbb',
                ticklabeloverflow: 'allow',
                ticklabelstep: 4,
                tickangle: 45,
                tickformat: soleil_.bucket < 24 ? '%x %X': '%x',
                type: 'datetime',
            },
            yaxis: {
                title: { text: unite },
                gridcolor: darkMode ? '#444' : '#bbb',
                color: darkMode ? '#fff' : '#000',
            },
            showlegend: true,
            legend: {
                xanchor: 'center',
                x: 0.5,
                y: -0.4,
                orientation: 'h',
            },
        }
        if (has_plot.has_plot) {
            Plotly!.update(plot, [soleil_, somme], layout)
        } else {
            Plotly!.newPlot(plot, [soleil_, somme], layout, {
                responsive: true,
                modeBarButtonsToRemove: modeBarButtonsToRemove,
            })
            //@ts-ignore
            plot.on('plotly_relayout', relayout_)
            has_plot.has_plot = true
        }
    let plotStyle = ''
    let darkMode = false
    if (browser) {
        darkMode =
            window.matchMedia &&
            window.matchMedia('(prefers-color-scheme: dark)').matches
        window
                  .matchMedia('(prefers-color-scheme: dark)')
                  .addEventListener('change', (event) => {
                      darkMode = !!event.matches
                      redraw()
                  })
    }
    let profils_ = Grain.profils($expert)
    expert.subscribe((value) => profils_ = Grain.profils(value))
    onMount(async () => {
        //@ts-ignore
        Plotly = await import('plotly.js-dist')
        s.p.puissance.subscribe((value) => {
            puissance = value
            initialised && updatePlot(puissance, communaute)
        })
        _communaute.subscribe((value) => {
            communaute = value
            initialised && updatePlot(puissance, communaute)
        })
        pvgis.subscribe((pvgis) => {
            console.log("pvgis updated")
            if(initialised && (pvgis.pvgis?.inputs != pvgis_)) {
                pvgis_ = pvgis.pvgis?.inputs || null
                updatePlot(puissance, communaute)
            }
        })
        for(let p of data.prms) {
            p.consentement = false
        }
        initialised = true
        updatePlot(puissance, communaute)
    })
    function addPrm(_ev: Event) {
        data.prms = data.prms
    }
    const pvgis: Writable<{ pvgis: null | PVGIS, loading: boolean }> = getContext("pvgis")
    let pvgis_: null | PVGISInputs = null
        data.prms.push({ prm: null, nom: '', prenom: '', siret: '', pro: true })
    import { browser } from '$app/environment'
    import { onMount, tick } from 'svelte'
    import { dev } from '$app/environment';
    import { assets as a } from '$app/paths'
    import type { Writable }from 'svelte/store'
    import { get }from 'svelte/store'
    import { getContext } from 'svelte'
    import { Grain } from '../../../../grain-types'
    import { base } from '$app/paths'
    import { chooseScale, relayout, modeBarButtonsToRemove } from '../../../../plot'
    import type { Sample } from '../../../../plot'
    import type {Derived, PVGIS, PVGISInputs} from '../calcul'
    import * as calcul from '../calcul'
    export let data: {
        id: string,
        accesParticuliers: boolean,
        prms: Grain.Prm[],
        active: boolean,
        profils: Grain.Profil[],
    };
    export let annee: Record<number, number[]> = {}
    console.log(data)
    export let assets: string = a;
    let s: Derived = getContext("simulation")
    const soleil: Writable<Sample> = getContext("soleil")
    const expert: Writable<boolean> = getContext("expert")
    let _communaute: Writable<(Grain.Communaute & {isMoving?: boolean}) | null> = getContext("communaute")
    const server = dev ? 'http://localhost:5173' : 'https://coturnix.fr'

<Simulation {data} />

    const d: Derived = getContext("simulation")

    const d: Derived = getContext('simulation')

    const fmt0 = Intl.NumberFormat('fr-FR', { maximumFractionDigits: 0 })

        let sum = 0;
        for(let i = 0; i < n; i++) {

        let sum = 0
        for (let i = 0; i < n; i++) {

        <span class="text-primary">Projetez-vous</span> dans votre
        projet.

        <span class="text-primary">Projetez-vous</span> dans votre projet.

                     >{format(sum($resultatNet, $N))}</span>

                >{format(sum($resultatNet, $N))}</span>

                <div class="titreligne tcellt">
                    Résultat net
                </div>

                <div class="titreligne tcellt">Résultat net</div>

            {#each Array(Math.ceil($N)) as _, i}

            {#each Array(Math.ceil($N)), i (i)}

                     >{format(sum($chiffreAffaires, $N))}</span>

                >{format(sum($chiffreAffaires, $N))}</span>

                <div class="titreligne tcellt">
                    Autoproduction (€)
                </div>
                <div class="titreligne tcellt">
                    Vente locale (€)
                </div>
                <div class="titreligne tcellt">
                    Vente de surplus (€)
                </div>

                <div class="titreligne tcellt">Autoproduction (€)</div>
                <div class="titreligne tcellt">Vente locale (€)</div>
                <div class="titreligne tcellt">Vente de surplus (€)</div>

                <div class="titreligne tcellt">
                    Chiffre d'affaires
                </div>

                <div class="titreligne tcellt">Chiffre d'affaires</div>

            {#each Array(Math.ceil($N)) as _, i}

            {#each Array(Math.ceil($N)), i (i)}

                            ).toFixed(0)}

                        ).toFixed(0)}

                            ).toFixed(0)}

                        ).toFixed(0)}

                            ((1 - $autoconso/100) * $tarifSurplus[i])
                            ).toFixed(0)}

                            ((1 - $autoconso / 100) * $tarifSurplus[i])
                        ).toFixed(0)}

                    <div class="tcellt">{#if i == 0}{$primeInvestissement}{:else}&nbsp;{/if}</div>

                    <div class="tcellt">
                        {#if i == 0}{$primeInvestissement}{:else}&nbsp;{/if}
                    </div>

                     >{format(sum($charges, $N))}</span>

                >{format(sum($charges, $N))}</span>

                <div class="titreligne tcellt">
                    Maintenance (€)
                </div>

                <div class="titreligne tcellt">Maintenance (€)</div>

                <div class="titreligne tcellt">
                    Assurance (€)
                </div>

                <div class="titreligne tcellt">Assurance (€)</div>

                <div class="titreligne tcellt">
                    Total charges
                </div>

                <div class="titreligne tcellt">Total charges</div>

            {#each Array(Math.ceil($N)) as _, i}

            {#each Array(Math.ceil($N)), i (i)}

            Cumulé : <span class="text-primary"
                     >{format(sum($ebe, $N))}</span>

            Cumulé : <span class="text-primary">{format(sum($ebe, $N))}</span>

                <div class="titreligne tcellt">
                    Valeur ajoutée (€)
                </div>

                <div class="titreligne tcellt">Valeur ajoutée (€)</div>

                <div class="titreligne tcellt">
                    Taxe foncière
                </div>

                <div class="titreligne tcellt">Taxe foncière</div>

            {#each Array(Math.ceil($N)) as _, i}

            {#each Array(Math.ceil($N)), i (i)}

                     >{format(sum($resultatNet, $N))}</span>

                >{format(sum($resultatNet, $N))}</span>

                <div class="titreligne tcellt">Onduleurs

                <div class="titreligne tcellt">
                    Onduleurs

                    ><i class="bi bi-question-circle" /></button>
                </div>
                <div class="titreligne tcellt">
                    Amortissement

                        aria-label="Provision pour le remplacement des onduleurs"
                        ><i class="bi bi-question-circle"></i></button>

                <div class="titreligne tcellt">Amortissement</div>
                <div class="titreligne tcellt">Intérêts dette senior</div>

                    Intérêts dette senior
                </div>
                <div class="titreligne tcellt">

                                      type="button"
                                      class="btn btn-sm btn-link align-baseline p-0 ms-2"
                                      data-bs-toggle="popover"
                                      data-bs-trigger="hover focus"
                                      data-bs-content="Dans un emprunt, compte bancaire qui permettra de payer le service de la dette si jamais l'entité emprunteuse n'est plus en mesure de le faire."
                                  ><i class="bi bi-question-circle" /></button>

                        type="button"
                        class="btn btn-sm btn-link align-baseline p-0 ms-2"
                        data-bs-toggle="popover"
                        data-bs-trigger="hover focus"
                        data-bs-content="Dans un emprunt, compte bancaire qui permettra de payer le service de la dette si jamais l'entité emprunteuse n'est plus en mesure de le faire."
                        aria-label="Dans un emprunt, compte bancaire qui permettra de payer le service de la dette si jamais l'entité emprunteuse n'est plus en mesure de le faire."
                        ><i class="bi bi-question-circle"></i></button>

                <div class="titreligne tcellt">
                    Résultat fiscal
                </div>
                <div class="titreligne tcellt">
                    Impôt sur les sociétés
                </div>
                <div class="titreligne tcellt">
                    Résultat net
                </div>

                <div class="titreligne tcellt">Résultat fiscal</div>
                <div class="titreligne tcellt">Impôt sur les sociétés</div>
                <div class="titreligne tcellt">Résultat net</div>

            {#each Array(Math.ceil($N)) as _, i}

            {#each Array(Math.ceil($N)), i (i)}

                {#each Array(Math.ceil($N)) as _, i}

                {#each Array(Math.ceil($N)), i (i)}

    import type { Grain } from '../../../../grain-types.ts';
    import type { Writable } from 'svelte/store'
    import { getContext, tick } from 'svelte'
    export let zoom: number = 5
    import { onMount, onDestroy } from 'svelte'
    export let assets: string = '/grain/static'
    import { browser } from '$app/environment'
    let redIcon: any = null
    let srv =
        import.meta.env.MODE == 'production'
        ? 'https://coturnix.fr'
        : 'http://localhost:5173'
    type Compteur_ = Grain.Compteur & { dot?: any };
    type Communaute_ = Grain.Communaute & { compteurs?: Compteur_[], circle?: any, isMoving?: boolean };
    let communaute: Writable<Communaute_ | null> = getContext("communaute")
    export let save: () => Promise<void> = async () => { };
    let derogation = $communaute?.derogation ?? "non"
    let map: any = null
    let circleOpts = {
        radius: 1000,
        stroke: true,
        fillOpacity: 0,
        color: '#b81413',
        weight: 3,
    }
    let leaflet: any = null;
    function changeDerogation (e: any) {
        console.log('Changederogation', derogation, $communaute, e)
        if($communaute) {
            $communaute.derogation = derogation;
            let d = derogationRayonKm() * 1000
            checkRayon($communaute, d)
            if ($communaute?.circle) {
                $communaute.circle.setRadius(d)
            } else {
                circleOpts.radius = d
                $communaute.circle = leaflet.circle($communaute, circleOpts)
                $communaute.circle.addTo(map!)
            }
            save()
        }
    }
    function derogationRayonKm(): number {
        if ($communaute?.derogation == "20") {
            return 10
        } else if ($communaute?.derogation == "10") {
            return 5
        } else {
            return 1
        }
    }
    type Commune = {
        nom: String,
        densite: number,
    }
    let communes: null | Commune[] = null
    async function checkRayon(latlng: Grain.LatLng| null, rayon: number) {
        if(latlng) {
            console.log("checkRayon");
            let resp = await fetch(`${srv}/api/intersect?lat=${latlng.lat}&lng=${latlng.lng}&rayon=${rayon}`, {
                credentials: 'include',
            })
            if (resp.status == 200) {
                communes = await resp.json()
            }
        }
    }
    let mapContainer: HTMLElement;
    onDestroy(() => {
        console.log("destroy", map);
        if(browser ) {
            delete (<any>document).coturnixMap;
        }
        // map && map.off && map.off(); map && map.remove && map.remove()
    });
    onMount(async () => {
        checkRayon($communaute, derogationRayonKm())
        console.log('map onload', browser)
        if (!browser) {
            return
        }
        const L = await import('leaflet')
        leaflet = L;
        await import('leaflet.fullscreen')
        const G = await import('leaflet-gesture-handling')
        // @ts-ignore
        L.Map.addInitHook('addHandler', 'gestureHandling', G.GestureHandling)
        await tick();
        console.log("Map.svelte")
        map = L.map(L.DomUtil.create('div'), {
            // @ts-ignore
            fullscreenControl: true,
            fullscreenControlOptions: {
                position: 'topleft',
            },
            attributionControl: false,
            // @ts-ignore
            gestureHandling: true,
        });
        (<any>document).coturnixMap = map
        mapContainer.appendChild(map.getContainer());
        map.getContainer().style.width = '100%';
        map.getContainer().style.height = '100%';
        map.invalidateSize();
        if ($communaute) {
            derogation = $communaute.derogation;
            circleOpts.radius = derogationRayonKm() * 1000;
            $communaute.circle = L.circle($communaute, circleOpts).addTo(map)
            map.setView($communaute, zoom)
        } else {
            map.setView({ lat: 46, lng: 3 }, 5)
        }
        let layer = L.tileLayer(
            `https://tile.openstreetmap.org/{z}/{x}/{y}.png`,
            {
                minZoom: 0,
                maxZoom: 18,
                attribution: 'IGN-F/Geoportail',
                tileSize: 256,
                noWrap: true,
            }
        ).addTo(map)
        layer.on('tileerror', (e) => {
            console.log(e)
        })
        if (!redIcon) {
            redIcon = L.icon({
                iconUrl: `${assets}/signal-red.png`,
                iconRetinaUrl: `${assets}/signal-red.png`,
                iconAnchor: [12, 41],
            } as L.IconOptions)
        }
        if($communaute?.compteurs) {
            for(let c of $communaute.compteurs) {
                c.dot = L.marker(c, {
                    icon: redIcon!,
                    draggable: false,
                })
                c.dot.addTo(map)
            }
        }
        map.on('zoomend', function (_: any) {
            zoom = map.getZoom()
        })
        let initialCentre: null | { lat: number; lng: number } = null
        let invalidDrag = false
        map.on('mousemove', function (e: any) {
            if (invalidDrag) {
                return
            }
            if ($communaute?.circle && e.originalEvent.shiftKey) {
                // let m = document.getElementById('descrmap')
                // m!.focus()
                let d = derogationRayonKm() * 1000
                if (initialCentre) {
                    let testCentre = {
                        lat: e.latlng.lat - initialCentre.lat,
                        lng: e.latlng.lng - initialCentre.lng,
                    }
                    if (!checkDistance(testCentre, $communaute.compteurs ?? [], d)) {
                        invalidDrag = true
                        return
                    }
                    $communaute.lat = testCentre.lat
                    $communaute.lng = testCentre.lng
                    $communaute.circle.setLatLng($communaute);
                } else {
                    if (map.distance($communaute, e.latlng) <= d) {
                        $communaute.isMoving = true;
                        initialCentre = {
                            lat: e.latlng.lat - $communaute.lat,
                            lng: e.latlng.lng - $communaute.lng,
                        }
                    }
                }
            }
        })
        map.on('keyup', async (e: KeyboardEvent) => {
            console.log("KEYUP", e);
            if (e.originalEvent.key == 'Shift') {
                if($communaute) {
                    delete $communaute.isMoving;
                    checkRayon($communaute, derogationRayonKm() * 1000)
                    save()
                }
                console.log("invalidDrag");
                invalidDrag = false
                initialCentre = null
            }
        })
        map.on('click', function (e: any) {
            console.log(e);
            if(!$communaute) {
                    communaute.set({
                        lat: e.latlng.lat,
                        lng: e.latlng.lng,
                        compteurs: [],
                        derogation,
                    })
                    circleOpts.radius = derogationRayonKm() * 1000;
                    $communaute!.circle = L.circle(
                        e.latlng,
                        circleOpts
                    ).addTo(map)
                    checkRayon($communaute, derogationRayonKm() * 1000)
                }
                if(map.distance($communaute!, e.latlng) <= derogationRayonKm() * 1000) {
                    let dot = {
                        lat: e.latlng.lat,
                        lng: e.latlng.lng,
                        dot: L.marker(e.latlng, {
                            icon: redIcon!,
                            draggable: false,
                        }),
                        azimuth: 0,
                        inclinaison: 0,
                        puissance: 0,
                    };
                    dot.dot.addTo(map)
                    if(!$communaute!.compteurs) {
                        $communaute!.compteurs = []
                    }
                    $communaute!.compteurs.push(dot);
                    $communaute = $communaute;
                }
                save()
            }
        );
        recentrer()
    })
    function recentrer(zoom?: number) {
        if (!$communaute || !map) {
            return
        }
        let lng0 = 180
        let lng1 = -180
        let lat0 = 90
        let lat1 = -90
        let mar = 0.5
        let dy = (mar + (derogationRayonKm())) / 111
        let lat2 = $communaute.lat - dy
        let lat3 = $communaute.lat + dy
        let dx = dy / Math.cos(($communaute.lat * Math.PI) / 180)
        let lng2 = $communaute.lng - dx
        let lng3 = $communaute.lng + dx
        lng0 = Math.min(lng0, lng2)
        lng1 = Math.max(lng1, lng3)
        lat0 = Math.min(lat0, lat2)
        lat1 = Math.max(lat1, lat3)
        if (zoom === undefined && lng0 < lng1 && lat0 < lat1) {
            console.log([
                [lat0, lng0],
                [lat1, lng1],
            ])
            map.fitBounds(
                [
                    [lat0, lng0],
                    [lat1, lng1],
                ],
            )
        } else {
            map.setView($communaute, zoom)
        }
    }
  function reset() {
        if (!$communaute || !map) {
            return
        }
      $communaute.circle.removeFrom(map)
      for(let m of $communaute?.compteurs || []) {
          m.dot.removeFrom(map);
      }
      $communaute = null
  }
  function checkDistance(
      e: { lat: number; lng: number },
      compteurs: { lat: number, lng: number }[],
      d: number
  ): boolean {
      for (let v of compteurs) {
            let dist = map.distance(e, v)
            if (dist > d) {
                return false
            }
        }
        return true
    }
    function deleteCompteur(
        event: any,
        i: number,
    ) {
        event.preventDefault();
        $communaute!.compteurs![i].dot.removeFrom(map);
        $communaute!.compteurs!.splice(i, 1);
        $communaute = $communaute;
        save()
    }
    let geoc = false;
    let endroit: string = ""
  function diff(a: string, b: string): number {
      const m = a.length, n = b.length;
      const dp = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
      dp[0] = dp[0].map((_, j) => j);
      dp.forEach((row, i) => row[0] = i);
      for (let i = 1; i <= m; i++) {
          for (let j = 1; j <= n; j++) {
              if (a[i - 1] === b[j - 1]) {
                  dp[i][j] = dp[i - 1][j - 1];
              } else {
                  dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
              }
          }
      }
      return dp[m][n];
  }
  async function geocoding(e: Event) {
      e.preventDefault()
        geoc = true
        await tick()
        let resp = await fetch(
            `https://data.geopf.fr/geocodage/search?q=${endroit}`
        )
        geoc = false
        if (resp.status == 200) {
            const b = await resp.json()
            console.log("features", b);
            if('features' in b && b.features.length) {
                let min = -1;
                let argmin = 0;
                for(let i = 0; i < b.features.length; i++) {
                    const d = diff(b.features[i].properties.label, endroit)
                    if(min < 0 || d < min) {
                        min = d;
                        argmin = i
                    }
                }
                console.log("diff", min, argmin);
                if(!$communaute) {
                    communaute.set({
                        lat: b.features[argmin].geometry.coordinates[1],
                        lng: b.features[argmin].geometry.coordinates[0],
                        compteurs: [],
                        derogation,
                    })
                }
                $communaute!.lng = b.features[argmin].geometry.coordinates[0]
                $communaute!.lat = b.features[argmin].geometry.coordinates[1]
            }
            if ($communaute) {
                let d = derogationRayonKm() * 1000
                await checkRayon($communaute, d)
                circleOpts.radius = d
                if($communaute.circle) {
                    $communaute.circle.setLatLng($communaute)
                } else {
                    $communaute.circle = leaflet.circle($communaute, circleOpts).addTo(map!)
                }
                recentrer(d == 10000 ? 10 : (d == 5000 ? 11 : 12))
            }
        }
        return null
    }

    import Description from './Description.svelte'

<svelte:head>
    <link rel="stylesheet" href="{assets}/leaflet.css" />
    <link rel="stylesheet" href="{assets}/leafletfs.css" />
    <link rel="stylesheet" href="{assets}/leaflet-gesture-handling.min.css" />
</svelte:head>
<div
    class="tab-pane fade active show p-3"
    id="description-tab-pane"
    role="tabpanel"
    aria-labelledby="description-tab"
    tabindex="0">
    <h3 class="my-3 fs-1 fw-bold">
        Quelques <span class="text-primary">détails</span> de plus.
    </h3>
    <div class="my-3">
        Cliquez sur la carte ci-dessous pour ajouter des compteurs, ou cliquez en maintenant la touche Shift pour positionner la communauté.
    </div>
    <div class="my-3">
        <form on:submit={geocoding}>
            <div class="input-group">
                <input type="text" class="form-control" bind:value={endroit}/>
                <button class="btn btn-sm btn-outline-primary" on:click={geocoding}>Recherche
                    {#if geoc}
                        <div class="spinner-border" style="margin-left:0.2em; width:1em;height:1em"></div>
                    {/if}
                </button>
            </div>
        </form>
    </div>
    <div bind:this={mapContainer} class="w-100" style="height:500px"></div>
    <div class="d-flex flex-column">
        <button
            class="btn btn-sm btn-outline-secondary my-2 ms-auto"
            on:click={(_) => recentrer(zoom)}>Recentrer</button>
        <button
            class="btn btn-sm btn-outline-secondary my-2 ms-auto"
            on:click={reset}>Reset</button>
        {#if $communaute?.compteurs?.length}
            <div class="my-3">
                <table class="table">
                    <thead>
                        <tr><th>Puissance</th><th>Azimuth (le Sud est à 0°, l'Est à -90°, l'Ouest à 90°)</th><th>Inclinaison</th><th></th></tr>
                    </thead>
                    <tbody>
                        {#each $communaute.compteurs as c, i}
                            <tr>
                                <td>
                                    <input
                                        type="number"
                                        class="form-control"
                                        bind:value={c.puissance} />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        class="form-control"
                                        bind:value={c.azimuth} />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        class="form-control"
                                        bind:value={c.inclinaison} />
                                </td>
                                <td>
                                    <button class="btn btn-sm btn-outline-primary" on:click={(e) => deleteCompteur(e, i)}><i class="bi bi-trash"/></button>
                                </td>
                            </tr>
                        {/each}
                    </tbody>
                </table>
            </div>
        {/if}
        <div class="p-3 overflow-auto">
            <label for="derog" class="form-label">
                Extension de périmètre (habitat rural et/ou dispersé)
            </label>&nbsp;<button type="button"
                                  class="btn btn-link align-baseline p-0"
                                  id="ext-popover"
                                  data-bs-toggle="popover"
                                  data-bs-trigger="hover focus"
                                  data-bs-content="Par dérogation, le rayon de la communauté peut être étendu à 5km ou 10km.">
                <i class="bi bi-question-circle" />
            </button>
            <select
                id="derog"
                class="form-select form-select-sm w-auto d-inline"
                name="derog"
                bind:value={derogation}
                on:change={changeDerogation}>
                <option value="non">Non</option>
                <option value="10">10km</option>
                <option value="20">20km</option>
            </select>
            {#if communes && communes.length}
                <h4 class="mt-5">Communes concernées</h4>
                <table class="table">
                    <thead>
                        <tr><th>Nom</th><th>Éligibilité</th></tr>
                    </thead>
                    <tbody>
                        {#each communes as c}
                            <tr><td>{c.nom}</td><td>{#if c.densite >= 5}20km{:else if c.densite >= 3}10km{#if derogation=='20' }<i class="ms-3 text-danger bi bi-exclamation-triangle"/>{/if}{:else}2km{#if derogation!='non' }<i class="ms-3 text-danger bi bi-exclamation-triangle"/>{/if}{/if}</td></tr>
                        {/each}
                    </tbody>
                </table>
            {/if}
        </div>
    </div>
</div>

<Description zoom={5} save={() => {}} />

import { readable, writable, derived, get } from 'svelte/store';
import type { Readable, Writable } from 'svelte/store';

import { readable, writable, derived, get } from 'svelte/store'
import type { Readable, Writable } from 'svelte/store'
import { asset, resolve } from '$app/paths'

  [Property in keyof Grain.SimulationCommunaute]: Writable<Grain.SimulationCommunaute[Property]>;

    [Property in keyof Grain.SimulationCommunaute]: Writable<
        Grain.SimulationCommunaute[Property]
    >

    p: _SimulationCommunaute

  p: _SimulationCommunaute;

    s: Grain.SimulationCommunaute

  s: Grain.SimulationCommunaute

    constructor(s: Grain.SimulationCommunaute) {
        this.s = s
        this.p = <_SimulationCommunaute>Object.fromEntries(
            Object.entries(s).map(([k, v]) => {
                /* eslint-disable @typescript-eslint/no-explicit-any */
                const w = writable(v)
                w.subscribe(
                    (value) =>
                        (this.s[k as keyof Grain.SimulationCommunaute] =
                            value as any)
                )
                return [k, w]
            })
        )

  constructor(s: Grain.SimulationCommunaute) {
    this.s = s
    this.p = <_SimulationCommunaute>Object.fromEntries(
      Object.entries(s).map(([k, v], _) => {
        let w = writable(v);
        w.subscribe((value) => this.s[k as keyof Grain.SimulationCommunaute] = value as any)
        return [k, w]
      })
    );
    this.N = writable(30);
    this.investissement = derived(
      [this.p.puissance, this.p.ratio, this.p.enedis],
      ([$puissance, $ratio, $enedis]) => $puissance ? $puissance * 1000 * $ratio + $enedis : 0)

        this.N = writable(30)

    this.apport = derived(
      [this.investissement, this.p.apport],
      ([$investissement, $apport]) => Math.min($investissement, $apport)
    )
    this.primeInvestissement = derived(
      this.p.puissance,
      ($puissance) => ($puissance <= 3 ? 0.30
        : $puissance <= 9 ? 0.23
          : $puissance <= 36 ? 0.20
            : $puissance <= 100 ? 0.10
              : 0) * 1000 * $puissance

        this.investissement = derived(
            [this.p.puissance, this.p.ratio, this.p.enedis],
            ([$puissance, $ratio, $enedis]) =>
                $puissance ? $puissance * 1000 * $ratio + $enedis : 0
        )

    )

        this.apport = derived(
            [this.investissement, this.p.apport],
            ([$investissement, $apport]) => Math.min($investissement, $apport)
        )

        this.primeInvestissement = derived(
            this.p.puissance,
            ($puissance) =>
                ($puissance <= 3
                    ? 0.3
                    : $puissance <= 9
                      ? 0.23
                      : $puissance <= 36
                        ? 0.2
                        : $puissance <= 100
                          ? 0.1
                          : 0) *
                1000 *
                $puissance
        )

    function tarifSurplus_(tarifCRE: any, puissance: number): number {
      let resultat = tarifCRE.prix[0]
      for (let i = 0; i < tarifCRE.limites.length; i++) {
        if (puissance < tarifCRE.limites[i]) {
          return resultat
        } else {
          resultat = tarifCRE.prix[i]

        function tarifSurplus_(tarifCRE: any, puissance: number): number {
            let resultat = tarifCRE.prix[0]
            for (let i = 0; i < tarifCRE.limites.length; i++) {
                if (puissance < tarifCRE.limites[i]) {
                    return resultat
                } else {
                    resultat = tarifCRE.prix[i]
                }
            }
            return resultat

      }
      return resultat
    }

    this.tarifSurplus = derived(
      [this.p.tarif_cre, this.p.puissance, this.N],
      ([$tarifCRE, $puissance, $N],
        _,
        update
      ) => {
        update((tarifSurplus) => {
          if (!tarifSurplus || tarifSurplus.length < $N) {
            tarifSurplus = Array($N);
          }
          let t = tarifSurplus_($tarifCRE, $puissance);
          for (let i = 0; i < $N; i++) {
            tarifSurplus[i] = t * Math.pow(1 + $tarifCRE.inflation / 100, i)
          }
          return tarifSurplus
        })
      }
    );

        this.tarifSurplus = derived(
            [this.p.tarif_cre, this.p.puissance, this.N],

    this.productionAnnuelle = derived(
      [this.p.productible, this.p.puissance, this.p.degradation, this.N],
      ([$productible, $puissance, $degradation, $N], _, update) => {
        update((prod) => {
          if (!prod || prod.length < $N) {
            prod = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            prod[i] = H.productionAnnuelle($productible, $puissance, $degradation, i)
          }
          return prod
        })
      }
    )

            ([$tarifCRE, $puissance, $N], _, update) => {
                update((tarifSurplus) => {
                    if (!tarifSurplus || tarifSurplus.length < $N) {
                        tarifSurplus = Array($N)
                    }
                    const t = tarifSurplus_($tarifCRE, $puissance)
                    for (let i = 0; i < $N; i++) {
                        tarifSurplus[i] =
                            t * Math.pow(1 + $tarifCRE.inflation / 100, i)
                    }
                    return tarifSurplus
                })
            }
        )

    this.tarifLocal = derived(
      [this.p.prix, this.p.inflation, this.N],
      ([$prix, $inflation, $N], _, update) => {
        update((tarif) => {
          if (!tarif || tarif.length < $N) {
            tarif = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            tarif[i] = $prix * Math.pow(1 + $inflation / 100, i)
          }
          return tarif
        })
      }
    )

        this.productionAnnuelle = derived(
            [this.p.productible, this.p.puissance, this.p.degradation, this.N],
            ([$productible, $puissance, $degradation, $N], _, update) => {
                update((prod) => {
                    if (!prod || prod.length < $N) {
                        prod = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        prod[i] = H.productionAnnuelle(
                            $productible,
                            $puissance,
                            $degradation,
                            i
                        )
                    }
                    return prod
                })
            }
        )

    this.tarifAllo = derived(
      [this.p.cout_elec, this.p.inflation_elec, this.N],
      ([$coutElec, $inflationElec, $N], _, update) => {
        update((tarif) => {
          if (!tarif || tarif.length < $N) {
            tarif = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            tarif[i] = $coutElec * Math.pow(1 + $inflationElec / 100, i)
          }
          return tarif
        })
      }
    )

        this.tarifLocal = derived(
            [this.p.prix, this.p.inflation, this.N],
            ([$prix, $inflation, $N], _, update) => {
                update((tarif) => {
                    if (!tarif || tarif.length < $N) {
                        tarif = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        tarif[i] = $prix * Math.pow(1 + $inflation / 100, i)
                    }
                    return tarif
                })
            }
        )

    this.chiffreAffaires = derived(
      [this.primeInvestissement, this.productionAnnuelle,
      this.p.autoconso, this.tarifLocal, this.tarifSurplus,
      this.p.autoprod, this.tarifAllo, this.N],
      ([$primeInvestissement, $productionAnnuelle, $autoconso, $tarifLocal, $tarifSurplus, $autoprod, $tarifAllo, $N], _, update) => {
        update((ca) => {
          if (!ca || ca.length < $N) {
            ca = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            ca[i] = (i == 0 ? $primeInvestissement : 0)
              + $productionAnnuelle[i] * (
                $autoconso / 100 * $tarifLocal[i] +
                (1 - $autoconso / 100) * $tarifSurplus[i] +
                ($autoprod / 100 * $tarifAllo[i])
              )
          }
          return ca
        })
      }
    )

        this.tarifAllo = derived(
            [this.p.cout_elec, this.p.inflation_elec, this.N],
            ([$coutElec, $inflationElec, $N], _, update) => {
                update((tarif) => {
                    if (!tarif || tarif.length < $N) {
                        tarif = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        tarif[i] =
                            $coutElec * Math.pow(1 + $inflationElec / 100, i)
                    }
                    return tarif
                })
            }
        )

    this.turpe = derived(
      [this.p.puissance, this.p.turpe, this.p.autoconso, this.productionAnnuelle, this.p.turpe_injection, this.p.inflation, this.N],
      ([$puissance, $turpe, $autoconso, $productionAnnuelle, $turpeInjection, $inflation, $N], _, update) => {
        update((turpe) => {
          if (!turpe || turpe.length < $N) {
            turpe = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            turpe[i] = (
              $puissance * $turpe +
              (1 - $autoconso / 100) * $productionAnnuelle[i] * $turpeInjection
            ) * Math.pow(1 + $inflation / 100, i)
          }
          return turpe
        })
      }
    )

        this.chiffreAffaires = derived(
            [
                this.primeInvestissement,
                this.productionAnnuelle,
                this.p.autoconso,
                this.tarifLocal,
                this.tarifSurplus,
                this.p.autoprod,
                this.tarifAllo,
                this.N,
            ],
            (
                [
                    $primeInvestissement,
                    $productionAnnuelle,
                    $autoconso,
                    $tarifLocal,
                    $tarifSurplus,
                    $autoprod,
                    $tarifAllo,
                    $N,
                ],
                _,
                update
            ) => {
                update((ca) => {
                    if (!ca || ca.length < $N) {
                        ca = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        ca[i] =
                            (i == 0 ? $primeInvestissement : 0) +
                            $productionAnnuelle[i] *
                                (($autoconso / 100) * $tarifLocal[i] +
                                    (1 - $autoconso / 100) * $tarifSurplus[i] +
                                    ($autoprod / 100) * $tarifAllo[i])
                    }
                    return ca
                })
            }
        )

    this.assurance = derived(
      [this.investissement, this.p.assurance, this.p.inflation, this.N],
      ([$investissement, $assurance, $inflation, $N], _, update) => {
        update((assurance) => {
          if (!assurance || assurance.length < $N) {
            assurance = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            assurance[i] = (($investissement * $assurance) / 100)
              * Math.pow(1 + $inflation / 100, i)
          }
          return assurance
        })
      }
    )

        this.turpe = derived(
            [
                this.p.puissance,
                this.p.turpe,
                this.p.autoconso,
                this.productionAnnuelle,
                this.p.turpe_injection,
                this.p.inflation,
                this.N,
            ],
            (
                [
                    $puissance,
                    $turpe,
                    $autoconso,
                    $productionAnnuelle,
                    $turpeInjection,
                    $inflation,
                    $N,
                ],
                _,
                update
            ) => {
                update((turpe) => {
                    if (!turpe || turpe.length < $N) {
                        turpe = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        turpe[i] =
                            ($puissance * $turpe +
                                (1 - $autoconso / 100) *
                                    $productionAnnuelle[i] *
                                    $turpeInjection) *
                            Math.pow(1 + $inflation / 100, i)
                    }
                    return turpe
                })
            }
        )

    this.exploitation = derived(
      [this.p.puissance, this.p.maintenance, this.p.inflation, this.N],
      ([$puissance, $maintenance, $inflation, $N], _, update) => {
        update((expl) => {
          if (!expl || expl.length < $N) {
            expl = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            expl[i] = $puissance * $maintenance
              * Math.pow(1 + $inflation / 100, i)
          }
          return expl
        })
      }
    )

        this.assurance = derived(
            [this.investissement, this.p.assurance, this.p.inflation, this.N],
            ([$investissement, $assurance, $inflation, $N], _, update) => {
                update((assurance) => {
                    if (!assurance || assurance.length < $N) {
                        assurance = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        assurance[i] =
                            (($investissement * $assurance) / 100) *
                            Math.pow(1 + $inflation / 100, i)
                    }
                    return assurance
                })
            }
        )

    this.divers = derived(
      [this.p.divers, this.p.puissance, this.p.inflation, this.N],
      ([$divers, $puissance, $inflation, $N], _, update) => {
        update((divers) => {
          if (!divers || divers.length < $N) {
            divers = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            divers[i] = $divers * $puissance
              * Math.pow(1 + $inflation / 100, i)
          }
          return divers
        })
      }
    )

        this.exploitation = derived(
            [this.p.puissance, this.p.maintenance, this.p.inflation, this.N],
            ([$puissance, $maintenance, $inflation, $N], _, update) => {
                update((expl) => {
                    if (!expl || expl.length < $N) {
                        expl = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        expl[i] =
                            $puissance *
                            $maintenance *
                            Math.pow(1 + $inflation / 100, i)
                    }
                    return expl
                })
            }
        )

    this.charges = derived(
      [this.investissement, this.p.frais_divers, this.exploitation, this.turpe, this.assurance, this.divers, this.N],
      ([$investissement, $fraisDivers, $exploitation, $turpe, $assurance, $divers, $N], _, update) => {
        update((charges) => {
          if (!charges || charges.length < $N) {
            charges = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            charges[i] = ($investissement && i == 0 ? $fraisDivers : 0) + $exploitation[i] + $turpe[i] + $assurance[i] + $divers[i]
          }
          return charges
        })
      }
    )

        this.divers = derived(
            [this.p.divers, this.p.puissance, this.p.inflation, this.N],
            ([$divers, $puissance, $inflation, $N], _, update) => {
                update((divers) => {
                    if (!divers || divers.length < $N) {
                        divers = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        divers[i] =
                            $divers *
                            $puissance *
                            Math.pow(1 + $inflation / 100, i)
                    }
                    return divers
                })
            }
        )

    this.valeurAjoutee = derived(
      [this.chiffreAffaires, this.charges, this.N],
      ([$chiffreAffaires, $charges, $N], _, update) => {
        update((va) => {
          if (!va || va.length < $N) {
            va = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            va[i] = $chiffreAffaires[i] - $charges[i]
          }
          return va
        })
      }
    )

        this.charges = derived(
            [
                this.investissement,
                this.p.frais_divers,
                this.exploitation,
                this.turpe,
                this.assurance,
                this.divers,
                this.N,
            ],
            (
                [
                    $investissement,
                    $fraisDivers,
                    $exploitation,
                    $turpe,
                    $assurance,
                    $divers,
                    $N,
                ],
                _,
                update
            ) => {
                update((charges) => {
                    if (!charges || charges.length < $N) {
                        charges = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        charges[i] =
                            ($investissement && i == 0 ? $fraisDivers : 0) +
                            $exploitation[i] +
                            $turpe[i] +
                            $assurance[i] +
                            $divers[i]
                    }
                    return charges
                })
            }
        )

    this.amortissement = derived(
      [this.p.duree_amortissement, this.investissement, this.N],
      ([$dureeAmortissement, $investissement, $N], _, update) => {
        update((a) => {
          if (!a || a.length < $N) {
            a = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            if (i < $dureeAmortissement) {
              a[i] = $investissement / $dureeAmortissement
            } else {
              a[i] = 0

        this.valeurAjoutee = derived(
            [this.chiffreAffaires, this.charges, this.N],
            ([$chiffreAffaires, $charges, $N], _, update) => {
                update((va) => {
                    if (!va || va.length < $N) {
                        va = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        va[i] = $chiffreAffaires[i] - $charges[i]
                    }
                    return va
                })

          }
          return a
        })
      }
    );

        )

    this.provisionOnduleurs = derived(
      [this.p.puissance, this.p.provision_onduleurs, this.p.inflation, this.N],
      ([$puissance, $provision, $inflation, $N], _, update) => {
        update((a) => {
          if (!a || a.length < $N) {
            a = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            a[i] = $puissance * 1000 * $provision * Math.pow(1 + $inflation / 100, i) / 10
          }
          return a
        })
      }
    );

        this.amortissement = derived(
            [this.p.duree_amortissement, this.investissement, this.N],
            ([$dureeAmortissement, $investissement, $N], _, update) => {
                update((a) => {
                    if (!a || a.length < $N) {
                        a = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        if (i < $dureeAmortissement) {
                            a[i] = $investissement / $dureeAmortissement
                        } else {
                            a[i] = 0
                        }
                    }
                    return a
                })
            }
        )

    // Accise: taux dérogatoire d'1€/MWh jusqu'au 31/1/2025
    this.accise = derived(
      [this.productionAnnuelle, this.N],
      ([$productionAnnuelle, $N], _, update) => {
        update((a) => {
          if (!a || a.length < $N) {
            a = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            a[i] = $productionAnnuelle[i] * 0.001
          }
          return a
        })
      }
    );

        this.provisionOnduleurs = derived(
            [
                this.p.puissance,
                this.p.provision_onduleurs,
                this.p.inflation,
                this.N,
            ],
            ([$puissance, $provision, $inflation, $N], _, update) => {
                update((a) => {
                    if (!a || a.length < $N) {
                        a = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        a[i] =
                            ($puissance *
                                1000 *
                                $provision *
                                Math.pow(1 + $inflation / 100, i)) /
                            10
                    }
                    return a
                })
            }
        )

    // Exonération de taxe foncière: https://www.legifrance.gouv.fr/codes/article_lc/LEGIARTI000044996150
    this.taxeFonciere = readable(0)

        // Accise: taux dérogatoire d'1€/MWh jusqu'au 31/1/2025
        this.accise = derived(
            [this.productionAnnuelle, this.N],
            ([$productionAnnuelle, $N], _, update) => {
                update((a) => {
                    if (!a || a.length < $N) {
                        a = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        a[i] = $productionAnnuelle[i] * 0.001
                    }
                    return a
                })
            }
        )

    // Formule compliquée, exonéré sur les cas concrets
    this.cfe = readable(0)

        // Exonération de taxe foncière: https://www.legifrance.gouv.fr/codes/article_lc/LEGIARTI000044996150
        this.taxeFonciere = readable(0)

    this.ifer = derived(
        [this.p.puissance, this.p.ratio_dc_ac, this.N],
      ([$puissance, $ratio, $N], _, update) => {
        update((a) => {
          if (!a || a.length < $N) {
            a = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            a[i] = $puissance < 100 ? 0 : 3.394 * $puissance * $ratio
          }
          return a
        })
      }
    );

        // Formule compliquée, exonéré sur les cas concrets
        this.cfe = readable(0)

    this.impots = derived(
      [this.ifer, this.taxeFonciere, this.cfe, this.N],
      ([$ifer, $taxeFonciere, $cfe, $N], _, update) => {
        update((a) => {
          if (!a || a.length < $N) {
            a = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            a[i] = $ifer[i] + $taxeFonciere + $cfe
          }
          return a
        })
      }
    );

        this.ifer = derived(
            [this.p.puissance, this.p.ratio_dc_ac, this.N],
            ([$puissance, $ratio, $N], _, update) => {
                update((a) => {
                    if (!a || a.length < $N) {
                        a = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        a[i] =
                            $puissance < 100 ? 0 : 3.394 * $puissance * $ratio
                    }
                    return a
                })
            }
        )

    this.ebe = derived(
      [this.valeurAjoutee, this.impots, this.N],
      ([$va, $impots, $N], _, update) => {
        update((a) => {
          if (!a || a.length < $N) {
            a = Array($N);
          }
          for (let i = 0; i < $N; i++) {
            a[i] = $va[i] - $impots[i]
          }
          return a
        })
      }
    );

        this.impots = derived(
            [this.ifer, this.taxeFonciere, this.cfe, this.N],
            ([$ifer, $taxeFonciere, $cfe, $N], _, update) => {
                update((a) => {
                    if (!a || a.length < $N) {
                        a = Array($N)
                    }
                    for (let i = 0; i < $N; i++) {
                        a[i] = $ifer[i] + $taxeFonciere + $cfe
                    }
                    return a
                })
            }
        )