@mxfb/tools 0.2.3 → 1.0.0

package/agnostic/scrapers/@meteociel/index.d.ts

@@ -0,0 +1,36 @@
+import { type CityName } from './locations/index.js';
+import type { WeatherForecast } from '../../weather/types.js';
+import type { ForecastMode } from './types.js';
+/**
+ * Builds the Meteociel forecast page URL for a given city and forecast mode.
+ *
+ * @param cityName - The city identifier used to resolve Meteociel location data.
+ * @param mode - The forecast mode to use when building the URL.
+ * @returns The fully qualified Meteociel URL for the requested city and mode.
+ * @throws If the provided forecast mode is not supported.
+ */
+export declare function getCityAndModeUrl(cityName: CityName, mode: ForecastMode): string;
+/**
+ * Fetches a remote HTML page and decodes it using ISO-8859-1 encoding.
+ *
+ * @param url - The URL of the page to fetch.
+ * @returns The decoded HTML content of the fetched page.
+ */
+export declare function fetchPage(url: string): Promise<string>;
+/**
+ * Retrieves and scrapes weather forecast data for a given city and forecast mode.
+ *
+ * @param cityName - The city for which to retrieve weather forecasts.
+ * @param mode - The forecast mode determining the scraping strategy.
+ * @returns An array of weather forecasts enriched with city location metadata.
+ * @throws If the forecast mode is unknown or unsupported.
+ */
+export declare function scrap(cityName: CityName, mode: ForecastMode): Promise<WeatherForecast[]>;
+/**
+ * Scrapes 3-day GFS weather simple forecasts from a Meteociel HTML page.
+ *
+ * @param pageContent - The raw HTML content of the Meteociel forecast page.
+ * @returns An array of weather forecasts parsed from the page content.
+ * @throws If required data such as issue time or geolocation cannot be extracted.
+ */
+export declare function scrapSimpleGfsPrevisions(pageContent: string): WeatherForecast[];

package/agnostic/scrapers/@meteociel/index.js

@@ -0,0 +1,194 @@
+import {
+  citiesData
+} from "../../../chunks/chunk-JQLUR5LO.js";
+
+// src/agnostic/scrapers/@meteociel/index.ts
+import { JSDOM } from "jsdom";
+function getCityAndModeUrl(cityName, mode) {
+  const modeUrlChunk = mode === "simple-gfs" ? "previsions" : null;
+  if (modeUrlChunk === null) throw "invalid mode";
+  return `https://www.meteociel.fr/${modeUrlChunk}/${citiesData[cityName].id}/${citiesData[cityName].urlSuffix}.htm`;
+}
+async function fetchPage(url) {
+  const fetched = await fetch(url);
+  const buffer = await fetched.arrayBuffer();
+  const html = new TextDecoder("iso-8859-1").decode(buffer);
+  return html;
+}
+async function scrap(cityName, mode) {
+  const url = getCityAndModeUrl(cityName, mode);
+  const fetched = await fetchPage(url);
+  switch (mode) {
+    case "simple-gfs": {
+      const scraped = scrapSimpleGfsPrevisions(fetched);
+      return scraped.map((i) => ({
+        ...i,
+        location: {
+          ...i.location,
+          name: cityName
+        }
+      }));
+    }
+    default:
+      throw "unknown-mode";
+  }
+}
+function scrapSimpleGfsPrevisions(pageContent) {
+  const dom = new JSDOM(pageContent);
+  const { document } = dom.window;
+  const COLLECTED_ON = /* @__PURE__ */ new Date();
+  const h3Parent = Array.from(document.querySelectorAll("h3")).find((n) => n.textContent.includes("Pr\xE9visions m\xE9t\xE9o \xE0 3 jours"))?.parentElement;
+  const issueTimeNode = Array.from(h3Parent?.childNodes ?? []).find((n) => n.textContent?.includes("R\xE9actualis\xE9 \xE0"));
+  const dataTableNode = Array.from(document.querySelectorAll("tbody")).find((n) => {
+    const trChldCnt = n.querySelectorAll("tr").length;
+    return trChldCnt > 25 && trChldCnt < 35;
+  });
+  const forecastTableRows = Array.from(dataTableNode?.querySelectorAll("tr") ?? []).slice(2);
+  const locationNode = Array.from(
+    Array.from(document.querySelectorAll("p")).find((n) => n.textContent.includes("sont exp\xE9rimentales et d\xE9termin\xE9es \xE0 partir des donn\xE9es brutes de GFS, un mod\xE8le num\xE9rique am\xE9ricain"))?.childNodes ?? []
+  ).find((n) => n.textContent?.startsWith("Localisation de"));
+  const issuedOnRaw = issueTimeNode?.textContent?.match(/\b([0-9]{1,2}):([0-5][0-9])\b/)?.[0];
+  if (issuedOnRaw === void 0) throw "no-refresh-time-found";
+  const [issuedOnH, issuedOnM] = issuedOnRaw.split(":");
+  const issuedOnYesteredayMaybe = /* @__PURE__ */ new Date();
+  issuedOnYesteredayMaybe.setDate((/* @__PURE__ */ new Date()).getDate() - 1);
+  issuedOnYesteredayMaybe.setHours(parseInt(issuedOnH));
+  issuedOnYesteredayMaybe.setMinutes(parseInt(issuedOnM));
+  issuedOnYesteredayMaybe.setSeconds(0);
+  issuedOnYesteredayMaybe.setMilliseconds(0);
+  const issuedOnYesteredayMaybeNowDiff = Math.abs((/* @__PURE__ */ new Date()).getTime() - issuedOnYesteredayMaybe.getTime());
+  const issuedOnTodayMaybe = /* @__PURE__ */ new Date();
+  issuedOnTodayMaybe.setHours(parseInt(issuedOnH));
+  issuedOnTodayMaybe.setMinutes(parseInt(issuedOnM));
+  issuedOnTodayMaybe.setSeconds(0);
+  issuedOnTodayMaybe.setMilliseconds(0);
+  const issuedOnTodayMaybeNowDiff = Math.abs((/* @__PURE__ */ new Date()).getTime() - issuedOnTodayMaybe.getTime());
+  const ISSUED_ON = issuedOnYesteredayMaybeNowDiff > issuedOnTodayMaybeNowDiff ? issuedOnTodayMaybe : issuedOnYesteredayMaybe;
+  function parseLocation(input) {
+    const regex = /Latitude\s+([NS])\s+(\d+)°(\d+)'\s+\/\s+Longitude\s+([EW])\s+(\d+)°(\d+)'\s+\/\s+Altitude\s*:\s*(\d+)\s*m/;
+    const match = input.match(regex);
+    if (!match) throw new Error("Format de coordonn\xE9es invalide");
+    const [, latDir, latDeg, latMin, lonDir, lonDeg, lonMin, altStr] = match;
+    let lat = Number(latDeg) + Number(latMin) / 60;
+    let lon = Number(lonDeg) + Number(lonMin) / 60;
+    if (latDir === "S") lat = -1 * lat;
+    if (lonDir === "W") lon = -1 * lon;
+    const alt = Number(altStr);
+    return {
+      latitudeDeg: lat,
+      longitudeDeg: lon,
+      elevationM: alt
+    };
+  }
+  let LOCATION;
+  try {
+    LOCATION = parseLocation(locationNode?.textContent ?? "");
+  } catch (err) {
+    throw "no-geolocation-found";
+  }
+  let currentDateLabel = null;
+  const currentHour = /* @__PURE__ */ new Date();
+  currentHour.setMinutes(0);
+  currentHour.setSeconds(0);
+  currentHour.setMilliseconds(0);
+  let RETURNED = [];
+  for (const row of forecastTableRows) {
+    const cells = Array.from(row.querySelectorAll("td"));
+    if (cells.length < 10 || cells.length > 11) continue;
+    let dateCell = void 0;
+    let otherCells = [];
+    if (cells.length === 11) {
+      dateCell = cells[0];
+      otherCells.push(...cells.slice(1));
+    } else {
+      otherCells.push(...cells);
+    }
+    if (dateCell !== void 0) {
+      currentDateLabel = dateCell.textContent;
+    }
+    const [
+      hourCell,
+      tempCell,
+      _emptyCell1,
+      windDirCell,
+      windSpeedCell,
+      gustSpeedCell,
+      rainAmountCell,
+      hygrometryCell,
+      airPressureCell,
+      weatherCell
+    ] = otherCells;
+    const hour = hourCell?.textContent ?? null;
+    const temp = tempCell?.textContent ?? null;
+    const windDir = windDirCell?.querySelector("img")?.getAttribute("title") ?? null;
+    const [windDirName = null, windDirAngle = null] = windDir?.split(" : ") ?? [];
+    const windSpeed = windSpeedCell?.textContent ?? null;
+    const gustSpeed = gustSpeedCell?.textContent ?? null;
+    const rainAmount = rainAmountCell?.textContent === "--" ? null : rainAmountCell?.textContent ?? null;
+    const hygrometry = hygrometryCell?.textContent ?? null;
+    const airPressure = airPressureCell?.textContent ?? null;
+    const weather = weatherCell?.querySelector("img")?.getAttribute("title") ?? null;
+    const rawDay = currentDateLabel;
+    const foundDate = rawDay?.slice(3) ?? "0";
+    const pMonthFullDate = new Date(currentHour);
+    pMonthFullDate.setMonth(currentHour.getMonth() - 1);
+    pMonthFullDate.setDate(parseInt(foundDate));
+    pMonthFullDate.setHours(parseInt(hour ?? "00"));
+    const curMonthFullDate = new Date(currentHour);
+    curMonthFullDate.setDate(parseInt(foundDate));
+    curMonthFullDate.setHours(parseInt(hour ?? "00"));
+    const nMonthFullDate = new Date(currentHour);
+    nMonthFullDate.setMonth(currentHour.getMonth() + 1);
+    nMonthFullDate.setDate(parseInt(foundDate));
+    nMonthFullDate.setHours(parseInt(hour ?? "00"));
+    const eligibleDateTimesDiff = [
+      Math.abs(currentHour.getTime() - pMonthFullDate.getTime()),
+      Math.abs(currentHour.getTime() - curMonthFullDate.getTime()),
+      Math.abs(currentHour.getTime() - nMonthFullDate.getTime())
+    ];
+    const minDateDiff = Math.min(...eligibleDateTimesDiff);
+    const indexOfMinDateDiff = eligibleDateTimesDiff.indexOf(minDateDiff);
+    const date = indexOfMinDateDiff === 0 ? pMonthFullDate : indexOfMinDateDiff === 1 ? curMonthFullDate : indexOfMinDateDiff === 2 ? nMonthFullDate : currentHour;
+    const validityTo = new Date(date);
+    validityTo.setHours(date.getHours() + 3);
+    const VALIDITY = {
+      from: date,
+      to: validityTo
+    };
+    const TEMPERATURE = { tempC: parseFloat(temp?.replace(" \xB0C", "") ?? "") };
+    const HUMIDITY = { relativePercent: parseFloat(hygrometry?.replace(" %", "") ?? "") };
+    const WIND = {
+      speedMs: parseFloat(windSpeed ?? ""),
+      directionDeg: parseFloat(windDirAngle?.replace(" \xB0", "") ?? ""),
+      gustMs: parseFloat(gustSpeed ?? "")
+    };
+    const PRESSURE = { stationLevelHpa: parseFloat(airPressure?.replace(" hPa", "") ?? "") };
+    const SOURCE = {
+      provider: "M\xE9t\xE9ociel",
+      type: "model",
+      model: "GFS"
+    };
+    RETURNED.push({
+      issuedOn: ISSUED_ON,
+      location: LOCATION,
+      validity: VALIDITY,
+      temperature: TEMPERATURE,
+      humidity: HUMIDITY,
+      wind: WIND,
+      pressure: PRESSURE,
+      precipitationMmh: parseFloat(rainAmount ?? ""),
+      metadata: {
+        source: SOURCE,
+        description: weather ?? "unknown",
+        collectedOn: COLLECTED_ON
+      }
+    });
+  }
+  return RETURNED;
+}
+export {
+  fetchPage,
+  getCityAndModeUrl,
+  scrap,
+  scrapSimpleGfsPrevisions
+};

package/agnostic/scrapers/@meteociel/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/scrapers/@meteociel/locations/index.d.ts

@@ -0,0 +1,11 @@
+export declare const citiesData: {
+    paris11: {
+        readonly id: 27827;
+        readonly urlSuffix: "paris_11eme_arrondissement";
+    };
+};
+export type CityName = keyof typeof citiesData;
+export type CityData = {
+    id: number;
+    urlSuffix: string;
+};

package/agnostic/scrapers/@meteociel/locations/index.js

@@ -0,0 +1,6 @@
+import {
+  citiesData
+} from "../../../../chunks/chunk-JQLUR5LO.js";
+export {
+  citiesData
+};

package/agnostic/scrapers/@meteociel/types.d.ts

@@ -0,0 +1 @@
+export type ForecastMode = 'simple-gfs';

package/agnostic/weather/types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Core weather data types for archiving and exchanging meteorological information.
+ *
+ * The structures are inspired by WMO (World Meteorological Organization) guidance
+ * and CF Conventions. Units are encoded explicitly in property names to avoid
+ * ambiguity and to make transformations between systems easier and safer.
+ */
+/** Geographic location following the WGS84 reference system. */
+export type GeoLocation = {
+    /** Latitude in decimal degrees (-90 to +90). */ latitudeDeg: number;
+    /** Longitude in decimal degrees (-180 to +180). */ longitudeDeg: number;
+    /** Elevation in meters above mean sea level. */ elevationM?: number;
+    /** Human-readable place name (city, station, etc.). */ name?: string;
+    /** Country code in ISO 3166-1 alpha-2 format (e.g. "FR", "US"). */ countryCode31661a2?: string;
+    /** Administrative region, state, or province name. */ region?: string;
+};
+/** Source of observed meteorological data. */
+export type ObservationDataSource = {
+    /** Data provider name */ provider: string;
+    /** High-level type of source */ type: 'satellite' | 'radar' | 'station' | 'derived' | 'manual' | 'other';
+    /** Identifier of the observing station or sensor when applicable. */ stationId?: string;
+    /** URL pointing to the data source or documentation. */ url?: string;
+    /** Data license or usage terms (short free-text). */ license?: string;
+};
+/** Source of forecast data. Describes both deterministic and ensemble-based forecast systems. */
+export type ForecastDataSource = {
+    /** Provider or operator name */ provider: string;
+    /** Type of forecast product. */ type: 'model' | 'ensemble' | 'derived' | 'other';
+    /** Model name or product identifier (e.g. "GFS", "AROME"). */ model?: string;
+    /** Model version, configuration, or cycle identifier. */ modelVersion?: string;
+    /** Model initialization date */ runTime?: Date;
+    /** Ensemble member identifier for probabilistic forecasts. */ ensembleMember?: string;
+    /** URL pointing to model documentation or the data endpoint. */ url?: string;
+    /** Data license or usage terms for the forecast. */ license?: string;
+};
+/** Temperature-related fields. */
+export type Temperature = {
+    /** Air temperature in degrees Celsius. */ tempC: number;
+    /** Feels-like temperature in °C (wind chill or heat index depending on conditions). */ feelsLikeC?: number;
+    /** Dew point temperature in °C. */ dewPointC?: number;
+    /** Minimum temperature over the period in °C. */ minC?: number;
+    /** Maximum temperature over the period in °C. */ maxC?: number;
+};
+/** Humidity parameters. */
+export type Humidity = {
+    /** Relative humidity in percent (0–100). */ relativePercent: number;
+    /** Absolute humidity in grams per cubic meter. */ absoluteGm3?: number;
+};
+/** Wind according to common WMO conventions. */
+export type Wind = {
+    /** Mean wind speed in meters per second. */ speedMs: number;
+    /** Wind direction in degrees (0–360, where 0/360 = North, 90 = East). */ directionDeg: number;
+    /** Maximum gust speed in meters per second over the period. */ gustMs?: number;
+};
+/** Canonical list of WMO cloud genera. */
+export type CloudType = 'cirrus' | 'cirrocumulus' | 'cirrostratus' | 'altocumulus' | 'altostratus' | 'nimbostratus' | 'stratocumulus' | 'stratus' | 'cumulus' | 'cumulonimbus';
+/** Cloud cover information following common WMO recommendations. */
+export type CloudCover = {
+    /** Total cloud cover in percent (0–100). */ totalPercent: number;
+    /** Low-level cloud fraction in percent (0–100). */ lowPercent?: number;
+    /** Mid-level cloud fraction in percent (0–100). */ middlePercent?: number;
+    /** High-level cloud fraction in percent (0–100). */ highPercent?: number;
+    /** Cloud base height in meters above ground level. */ cloudBaseHeightM?: number;
+    /** Dominant cloud genus when it can be identified. */ dominantGenre?: CloudType;
+};
+/** Canonical list of atmospheric phenomena based on WMO classification. */
+export type AtmosphericPhenomenon = 'rain' | 'drizzle' | 'freezing-rain' | 'snow' | 'snow-grains' | 'ice-pellets' | 'hail' | 'fog' | 'mist' | 'haze' | 'smoke' | 'dust' | 'sand' | 'volcanic-ash' | 'thunderstorm' | 'squall' | 'funnel-cloud';
+/** Single atmospheric phenomenon, observed or forecast. */
+export type WeatherPhenomenon = {
+    /** Phenomenon type according to the WMO-inspired list. */ phenomenon: AtmosphericPhenomenon;
+    /** Qualitative intensity: "+" for heavy, "-" for light, or null for normal. */ intensity: '+' | '-' | null;
+    /** Optional free-text remark describing special characteristics. */ remark?: string;
+};
+/** Atmospheric pressure. */
+export type Pressure = {
+    /** Sea-level pressure in hectopascals (millibars). */ seaLevelHpa?: number;
+    /** Station-level pressure in hectopascals at the observing elevation. */ stationLevelHpa: number;
+};
+/** Visibility metrics. */
+export type Visibility = {
+    /** Horizontal visibility in meters. */ horizontalM?: number;
+    /** Vertical visibility in meters (e.g. ceiling height). */ verticalM?: number;
+};
+/** Solar radiation and UV information. */
+export type Solar = {
+    /** Global solar radiation in watts per square meter. */ radiationWm2?: number;
+    /** Dimensionless UV index, typically between 0 and ~12. */ uvIndex?: number;
+};
+/** Air quality indicators. */
+export type AirQuality = {
+    /** Fine particulate matter PM2.5 in micrograms per cubic meter. */ pm25Ugm3?: number;
+    /** Particulate matter PM10 in micrograms per cubic meter. */ pm10Ugm3?: number;
+    /** Ozone (O₃) concentration in micrograms per cubic meter. */ o3Ugm3?: number;
+    /** Nitrogen dioxide (NO₂) concentration in micrograms per cubic meter. */ no2Ugm3?: number;
+    /** Sulfur dioxide (SO₂) concentration in micrograms per cubic meter. */ so2Ugm3?: number;
+    /** Carbon monoxide (CO) concentration in micrograms per cubic meter. */ coUgm3?: number;
+};
+/** Quality metadata attached to an observation or measurement. */
+export type ObservationQualityMetadata = {
+    /** Status of the data, typically resulting from QC checks or post-processing. */ status?: 'verified' | 'unverified' | 'estimated' | 'interpolated' | 'suspect';
+    /** Free-text notes or comments about the data quality. */ notes?: string;
+};
+/** Validity period of a forecast or alert. */
+export type ValidityPeriod = {
+    /** Start of validity */ from: Date;
+    /** End of validity */ to: Date;
+};
+/** Weather alert or warning issued by an authority or provider. */
+export type WeatherAlert = {
+    /** Alert type or category (e.g. "wind", "flood", "heat"). */ type: string;
+    /** Severity level as a normalized qualitative scale. */ severity: 'minor' | 'moderate' | 'severe' | 'extreme';
+    /** Human-readable description of the alert and its expected impacts. */ description?: string;
+    /** Validity period of a forecast or alert. */ validity?: ValidityPeriod;
+};
+/** Probabilistic forecast data for a single parameter. */
+export type ProbabilisticData = {
+    /** Confidence level for the forecast (0–100%). */ confidencePercent?: number;
+    /** Temperature 10th percentile in °C (optimistic or cooler scenario). */ tempP10C?: number;
+    /** Temperature 90th percentile in °C (pessimistic or warmer scenario). */ tempP90C?: number;
+};
+/**
+ * Core weather data structure containing essential meteorological measurements.
+ *
+ * This type represents the fundamental weather parameters that can be used
+ * for both observations and forecasts. It follows WMO conventions and uses
+ * explicit unit encoding in property names to ensure clarity and type safety.
+ *
+ * All core measurements are required, while some extended parameters
+ * (visibility, solar, air quality, alerts) are optional.
+ *
+ * @see WeatherObservation - For observation-specific data with location and time
+ * @see WeatherForecast - For forecast-specific data with validity periods
+ */
+export type WeatherDataCore = {
+    /** Temperature-related measurements at the observation time. */ temperature: Temperature;
+    /** Humidity-related measurements at the observation time. */ humidity: Humidity;
+    /** Wind conditions at the observation time. */ wind: Wind;
+    /** Instantaneous precipitation rates at the observation time. */ precipitationMmh: number;
+    /** Atmospheric pressure at or reduced to station/sea level. */ pressure: Pressure;
+    /** List of significant weather phenomena observed. */ phenomena?: WeatherPhenomenon[];
+    /** Cloud cover information at the observation time. */ clouds?: CloudCover;
+    /** Visibility metrics at the observation time. */ visibility?: Visibility;
+    /** Solar radiation and UV information at the observation time. */ solar?: Solar;
+    /** Air quality indicators at or near the observation site. */ airQuality?: AirQuality;
+    /** Weather alerts that are active for this forecast period and location. */ alerts?: WeatherAlert[];
+};
+/**
+ * Weather observation.
+ *
+ * Represents a real-world measurement or observation at a specific point in time,
+ * typically coming from an instrumented station or human report.
+ */
+export type WeatherObservation = WeatherDataCore & {
+    /** Exact time when the observation was made. */ observedOn: Date;
+    /** Geographic location of the observation. */ location: GeoLocation;
+    /** Observation metadata */ metadata?: {
+        /** Observation source metadata (station, provider, license...). */ source?: ObservationDataSource;
+        /** Time when the data was collected or ingested by the system. */ collectedOn?: Date;
+        /** Human-readable description or summary of the observation. */ description?: string;
+        /** Raw source data as received from the provider. */ rawData?: Record<string, any> | string;
+        /** Quality control and processing metadata for the observation. */ observationQuality?: ObservationQualityMetadata;
+    };
+};
+/**
+ * Weather forecast.
+ *
+ * Represents a forecast for a given future period, possibly including a mix
+ * of deterministic and probabilistic information as provided by a model.
+ */
+export type WeatherForecast = WeatherDataCore & {
+    /** Time when the forecast was issued. */ issuedOn: Date;
+    /** Period of time this forecast is valid for. */ validity: ValidityPeriod;
+    /** Geographic location to which the forecast applies. */ location: GeoLocation;
+    /** Observation metadata */ metadata?: {
+        /** Forecast model and source metadata. */ source?: ForecastDataSource;
+        /** Time when the data was collected or ingested by the system. */ collectedOn?: Date;
+        /** Human-readable description or summary of the observation. */ description?: string;
+        /** Raw source data as received from the provider. */ rawData?: Record<string, any> | string;
+        /** Associated probabilistic forecast information, if available. */ probabilistic?: ProbabilisticData;
+    };
+};

package/chunks/chunk-JQLUR5LO.js

@@ -0,0 +1,12 @@
+// src/agnostic/scrapers/@meteociel/locations/index.ts
+var citiesData = {
+  // Paris 11e
+  "paris11": {
+    id: 27827,
+    urlSuffix: "paris_11eme_arrondissement"
+  }
+};
+
+export {
+  citiesData
+};

package/components/Comp/index.d.ts

@@ -0,0 +1 @@
+export {};

package/node/index.d.ts

@@ -1,2 +1 @@
-import * as MxfbCliConfig from './mxfb-cli-config';
-export { MxfbCliConfig };
+export {};

package/package.json

@@ -1,41 +1,64 @@
 {
   "name": "@mxfb/tools",
-  "version": "0.2.3",
+  "version": "1.0.0",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mxfb/tools"
+    "url": "https://github.com/maximefabas/mf-tools"
   },
   "type": "module",
   "main": "index.js",
   "module": "index.js",
-  "peerDependencies": {
-    "@design-edito/tools": "^0.1.73",
-    "chalk": "^5.3.0",
-    "fs-extra": "^11.2.0",
-    "jsdom": "^24.1.1",
-    "node-fetch": "^3.3.2",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "sharp": "^0.33.3"
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.907.0",
+    "@aws-sdk/lib-storage": "^3.907.0",
+    "@design-edito/tools": "^0.2.41",
+    "@google-cloud/storage": "^7.17.2",
+    "@inquirer/prompts": "^8.2.0",
+    "ansi-regex": "^6.2.2",
+    "archiver": "^7.0.1",
+    "basic-ftp": "^5.0.5",
+    "chalk": "^5.6.2",
+    "express": "^5.1.0",
+    "multer": "^2.0.0",
+    "quantize": "^1.0.2",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "sharp": "^0.34.4",
+    "ssh2": "^1.17.0",
+    "ssh2-sftp-client": "^12.0.0",
+    "xss": "^1.0.15",
+    "zod": "^4.1.12"
   },
   "devDependencies": {
-    "@types/node": "^22.15.21",
+    "@preact/preset-vite": "^2.10.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/preact": "^3.2.4",
+    "@testing-library/react": "^16.3.1",
+    "@types/archiver": "^6.0.3",
+    "@types/express": "^5.0.2",
+    "@types/jsdom": "^27.0.0",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^24.7.1",
     "@types/prompts": "^2.4.9",
-    "@types/semver": "^7.7.0",
-    "chalk": "^5.4.1",
+    "@types/quantize": "^1.0.2",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.1",
+    "@types/semver": "^7.7.1",
+    "@types/sharp": "^0.31.1",
+    "@types/ssh2-sftp-client": "^9.0.4",
+    "@vitejs/plugin-react": "^5.1.2",
     "chokidar-cli": "^3.0.0",
-    "concurrently": "^9.1.2",
-    "esbuild": "^0.25.5",
+    "concurrently": "^9.2.1",
+    "esbuild": "^0.25.10",
+    "jsdom": "^27.4.0",
     "prompts": "^2.4.2",
-    "puppeteer": "^24.9.0",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
-    "semver": "^7.7.2",
-    "sharp": "^0.34.2",
+    "puppeteer": "^24.23.1",
+    "semver": "^7.7.3",
     "simple-git": "^3.27.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
   }
 }

package/agnostic/_WIP_tennis/index.d.ts

@@ -1,2 +0,0 @@
-export declare namespace Tennis {
-}

package/agnostic/_WIP_tennis/index.js

@@ -1,62 +0,0 @@
-// src/agnostic/_WIP_tennis/index.ts
-var Tennis;
-((Tennis2) => {
-  function getGameScore(game) {
-    const score = [0, 0];
-    game.forEach((point) => {
-      if (score.includes(5)) return;
-      const winnerPos = point ? 0 : 1;
-      const loserPos = point ? 1 : 0;
-      const winnerCurrScore = score[winnerPos];
-      const loserCurrScore = score[loserPos];
-      if (loserCurrScore === 5 || winnerCurrScore === 5) return;
-      if (loserCurrScore === 4 && winnerCurrScore === 3) {
-        score[loserPos] = 3;
-        return;
-      }
-      if (loserCurrScore === 3 && winnerCurrScore === 4) {
-        score[winnerPos] = 5;
-        return;
-      }
-      if (winnerCurrScore === 3) {
-        score[winnerPos] = 5;
-        return;
-      }
-      score[winnerPos]++;
-      return;
-    });
-    return score;
-  }
-  function getGameWinner(gameScore) {
-    const [scoreA, scoreB] = gameScore;
-    if (scoreA === 5) return true;
-    if (scoreB === 5) return false;
-    return null;
-  }
-  function getSetScore(set) {
-    const score = [0, 0];
-    let foundUnfinishedGame = false;
-    set.forEach((game) => {
-      if (foundUnfinishedGame) return;
-      if (score.includes(7)) return;
-      const [scoreA, scoreB] = score;
-      if (scoreA >= 6 && scoreB < 5) return;
-      if (scoreB <= 6 && scoreA < 5) return;
-      const gameScore = getGameScore(game);
-      const gameWinner = getGameWinner(gameScore);
-      if (gameWinner === true) {
-        score[0]++;
-        return;
-      }
-      if (gameWinner === false) {
-        score[1]++;
-        return;
-      }
-      foundUnfinishedGame = true;
-    });
-    return score;
-  }
-})(Tennis || (Tennis = {}));
-export {
-  Tennis
-};

package/agnostic/index.d.ts

@@ -1,4 +0,0 @@
-import * as MiscNamespace from './misc';
-export declare namespace Agnostic {
-    export import Misc = MiscNamespace;
-}

package/agnostic/misc/elo/index.d.ts

@@ -1,31 +0,0 @@
-export declare namespace Elo {
-    const K_FACTOR = 32;
-    /**
-     * Calcule la probabilité de gain de A en fonction des scores Elo de A et B.
-     * @param eloA Le score Elo du joueur A.
-     * @param eloB Le score Elo du joueur B.
-     * @returns La probabilité que le joueur A gagne contre le joueur B.
-     */
-    function getWinProbability(eloA: number, eloB: number): number;
-    /**
-     * Calcule les nouveaux classements Elo pour les scénarios de victoire de A, de B et de match nul.
-     * @param eloA Le score Elo actuel du joueur A.
-     * @param eloB Le score Elo actuel du joueur B.
-     * @param kFactor Facteur K pour les calculs Elo (facultatif, valeur par défaut = 32).
-     * @returns Un objet contenant les nouveaux classements Elo pour chaque scénario de résultat.
-     */
-    function getOutcome(eloA: number, eloB: number, kFactor?: number): {
-        aWins: {
-            eloA: number;
-            eloB: number;
-        };
-        bWins: {
-            eloA: number;
-            eloB: number;
-        };
-        null: {
-            eloA: number;
-            eloB: number;
-        };
-    };
-}

package/agnostic/misc/elo/index.js

@@ -1,6 +0,0 @@
-import {
-  Elo
-} from "../../../chunks/chunk-ZC5RZBNY.js";
-export {
-  Elo
-};

package/agnostic/misc/index.d.ts

@@ -1,6 +0,0 @@
-import { Elo as EloNamespace } from './elo';
-import { Tennis as TennisNamespace } from './tennis';
-export declare namespace Misc {
-    export import Elo = EloNamespace;
-    export import Tennis = TennisNamespace;
-}

package/agnostic/misc/index.js

@@ -1,16 +0,0 @@
-import {
-  Elo
-} from "../../chunks/chunk-ZC5RZBNY.js";
-import {
-  Tennis
-} from "../../chunks/chunk-TTZHPIH7.js";
-
-// src/agnostic/misc/index.ts
-var Misc;
-((Misc2) => {
-  Misc2.Elo = Elo;
-  Misc2.Tennis = Tennis;
-})(Misc || (Misc = {}));
-export {
-  Misc
-};

package/agnostic/misc/tennis/index.d.ts

@@ -1,60 +0,0 @@
-export declare namespace Tennis {
-    namespace Score {
-        type PointDescriptor = boolean;
-        type GameFormat = {
-            upTo: number;
-            diffToWin: number;
-        };
-        class Game {
-            private format;
-            private pointsSequence;
-            constructor(format: GameFormat);
-            add(point: PointDescriptor): this;
-            getNumericScore(): [number, number];
-            static numericToStringScoreValue(numScore: [number, number]): string;
-            getScore(): string;
-            isFinished(): boolean;
-            getWinner(): boolean | null;
-        }
-        type SetFormat = {
-            upTo: number;
-            diffToWin: number;
-            gamesFormat: GameFormat;
-            tieBreakAt: number | null;
-            tieBreakFormat: GameFormat;
-        };
-        class Set {
-            private format;
-            private pointsSequence;
-            constructor(format: SetFormat);
-            add(point: PointDescriptor): void;
-            getGames(): Game[];
-            getNumericScore(): {
-                games: [number, number];
-                currentGame?: [number, number];
-            };
-            getScore(): string;
-            isFinished(): boolean;
-            getWinner(): boolean | null;
-        }
-        type MatchFormat = {
-            upTo: number;
-            setsFormat: SetFormat;
-            lastSetFormat: SetFormat;
-        };
-        class Match {
-            private format;
-            private pointsSequence;
-            constructor(format: MatchFormat);
-            add(point: PointDescriptor): void;
-            getSets(): Set[];
-            getNumericScore(): {
-                sets: [number, number][];
-                currentGame?: [number, number];
-            };
-            getScore(): string;
-            isFinished(): boolean;
-            getWinner(): boolean | null;
-        }
-    }
-}

package/agnostic/misc/tennis/index.js

@@ -1,6 +0,0 @@
-import {
-  Tennis
-} from "../../../chunks/chunk-TTZHPIH7.js";
-export {
-  Tennis
-};

package/chunks/chunk-TTZHPIH7.js

@@ -1,237 +0,0 @@
-// src/agnostic/misc/tennis/index.ts
-var Tennis;
-((Tennis2) => {
-  let Score;
-  ((Score2) => {
-    class Game {
-      format;
-      pointsSequence = [];
-      constructor(format) {
-        this.format = format;
-      }
-      add(point) {
-        if (!this.isFinished()) this.pointsSequence.push(point);
-        return this;
-      }
-      getNumericScore() {
-        const { pointsSequence, format } = this;
-        const { upTo, diffToWin } = format;
-        return pointsSequence.reduce((reduced, point) => {
-          const [aScore, bScore] = reduced;
-          const aWon = aScore >= upTo && aScore - bScore >= diffToWin;
-          const bWon = bScore >= upTo && bScore - aScore >= diffToWin;
-          if (aWon || bWon) return reduced;
-          return point ? [aScore + 1, bScore] : [aScore, bScore + 1];
-        }, [0, 0]);
-      }
-      static numericToStringScoreValue(numScore) {
-        const [aScore, bScore] = numScore;
-        if (aScore >= 3 && bScore >= 3) {
-          if (aScore === bScore) return "deuce";
-          if (aScore < bScore) return "Ad/40";
-          return "40/Ad";
-        }
-        const strScoresList = ["0", "15", "30", "40"];
-        return `${strScoresList.at(aScore) ?? "?"}/${strScoresList.at(bScore) ?? "?"}`;
-      }
-      getScore() {
-        return Game.numericToStringScoreValue(this.getNumericScore());
-      }
-      isFinished() {
-        const { format } = this;
-        const { upTo, diffToWin } = format;
-        const [aScore, bScore] = this.getNumericScore();
-        const maxScoreReached = Math.max(aScore, bScore) >= upTo;
-        const diffReached = Math.abs(aScore - bScore) >= diffToWin;
-        if (maxScoreReached && diffReached) return true;
-        return false;
-      }
-      getWinner() {
-        if (!this.isFinished()) return null;
-        const [aScore, bScore] = this.getNumericScore();
-        return aScore > bScore;
-      }
-    }
-    Score2.Game = Game;
-    class Set {
-      format;
-      pointsSequence = [];
-      constructor(format) {
-        this.format = format;
-      }
-      add(point) {
-        this.pointsSequence.push(point);
-      }
-      getGames() {
-        const { format } = this;
-        const { upTo, diffToWin, gamesFormat, tieBreakFormat, tieBreakAt } = format;
-        let aGames = 0;
-        let bGames = 0;
-        const games = [];
-        const { pointsSequence } = this;
-        pointsSequence.forEach((point) => {
-          const maxGamesReached = Math.max(aGames, bGames) >= upTo;
-          const diffReached = Math.abs(aGames - bGames) >= diffToWin;
-          if (maxGamesReached && diffReached) return;
-          const lastGameInList = games.at(-1);
-          const lastGameIsFinished = lastGameInList?.isFinished();
-          if (lastGameInList === void 0 || lastGameIsFinished === true) {
-            const isTiebreak = aGames === bGames && aGames === tieBreakAt;
-            if (isTiebreak) games.push(new Game(tieBreakFormat));
-            else games.push(new Game(gamesFormat));
-          }
-          const currentGame = games.at(-1);
-          if (currentGame === void 0) throw "Something went wrong, this should't be undefined";
-          currentGame.add(point);
-          const currentGameWinner = currentGame.getWinner();
-          if (currentGameWinner === true) {
-            aGames += 1;
-          }
-          if (currentGameWinner === false) {
-            bGames += 1;
-          }
-        });
-        return games;
-      }
-      getNumericScore() {
-        const games = this.getGames();
-        let aScore = 0;
-        let bScore = 0;
-        games.forEach((game) => {
-          const winner = game.getWinner();
-          if (winner === true) {
-            aScore++;
-          }
-          if (winner === false) {
-            bScore++;
-          }
-        });
-        const lastGame = games.at(-1);
-        if (lastGame === void 0) return { games: [aScore, bScore] };
-        if (lastGame.isFinished() === false) return {
-          games: [aScore, bScore],
-          currentGame: lastGame.getNumericScore()
-        };
-        return { games: [aScore, bScore] };
-      }
-      getScore() {
-        const numericScore = this.getNumericScore();
-        const { games, currentGame } = numericScore;
-        if (currentGame === void 0) return `${games.join("/")}`;
-        return `${games.join("/")} ${Game.numericToStringScoreValue(currentGame)}`;
-      }
-      isFinished() {
-        const { format } = this;
-        const { upTo, diffToWin, tieBreakAt } = format;
-        const [aScore, bScore] = this.getNumericScore().games;
-        const maxGamesReached = Math.max(aScore, bScore) >= upTo;
-        const diffReached = Math.abs(aScore - bScore) >= diffToWin;
-        const tieBreakBeenPlayed = tieBreakAt !== null && Math.max(aScore, bScore) > tieBreakAt;
-        return tieBreakBeenPlayed || maxGamesReached && diffReached;
-      }
-      getWinner() {
-        if (!this.isFinished()) return null;
-        const [aScore, bScore] = this.getNumericScore().games;
-        return aScore > bScore;
-      }
-    }
-    Score2.Set = Set;
-    class Match {
-      format;
-      pointsSequence = [];
-      constructor(format) {
-        this.format = format;
-      }
-      add(point) {
-        this.pointsSequence.push(point);
-      }
-      getSets() {
-        const { format } = this;
-        const { upTo, setsFormat, lastSetFormat } = format;
-        let aSets = 0;
-        let bSets = 0;
-        const sets = [];
-        const { pointsSequence } = this;
-        pointsSequence.forEach((point) => {
-          const maxSetsReached = Math.max(aSets, bSets) >= upTo;
-          if (maxSetsReached) return;
-          const lastSetInList = sets.at(-1);
-          const lastSetIsFinished = lastSetInList?.isFinished();
-          if (lastSetInList === void 0 || lastSetIsFinished === true) {
-            const isLastSet = aSets === bSets && aSets === upTo - 1;
-            if (isLastSet) sets.push(new Set(lastSetFormat));
-            else sets.push(new Set(setsFormat));
-          }
-          const currentSet = sets.at(-1);
-          if (currentSet === void 0) throw "Something went wrong, this should't be undefined";
-          currentSet.add(point);
-          const currentSetWinner = currentSet.getWinner();
-          if (currentSetWinner === true) {
-            aSets += 1;
-          }
-          if (currentSetWinner === false) {
-            bSets += 1;
-          }
-        });
-        return sets;
-      }
-      getNumericScore() {
-        const sets = this.getSets();
-        const numericScore = {
-          sets: [],
-          currentGame: void 0
-        };
-        sets.forEach((set) => {
-          const setNumericScore = set.getNumericScore();
-          const { games, currentGame } = setNumericScore;
-          numericScore.sets.push(games);
-          if (currentGame !== void 0) {
-            numericScore.currentGame = currentGame;
-          }
-        });
-        return numericScore;
-      }
-      getScore() {
-        return this.getSets().map((set) => set.getScore()).join(" ");
-      }
-      isFinished() {
-        const { format } = this;
-        const { upTo } = format;
-        const sets = this.getSets();
-        let aSets = 0;
-        let bSets = 0;
-        sets.forEach((set) => {
-          const winner = set.getWinner();
-          if (winner === true) {
-            aSets++;
-          }
-          if (winner === false) {
-            bSets++;
-          }
-        });
-        return Math.max(aSets, bSets) >= upTo;
-      }
-      getWinner() {
-        if (!this.isFinished()) return null;
-        const sets = this.getSets();
-        let aSets = 0;
-        let bSets = 0;
-        sets.forEach((set) => {
-          const winner = set.getWinner();
-          if (winner === true) {
-            aSets++;
-          }
-          if (winner === false) {
-            bSets++;
-          }
-        });
-        return aSets > bSets;
-      }
-    }
-    Score2.Match = Match;
-  })(Score = Tennis2.Score || (Tennis2.Score = {}));
-})(Tennis || (Tennis = {}));
-
-export {
-  Tennis
-};

package/chunks/chunk-ZC5RZBNY.js

@@ -1,33 +0,0 @@
-// src/agnostic/misc/elo/index.ts
-var Elo;
-((Elo2) => {
-  Elo2.K_FACTOR = 32;
-  function getWinProbability(eloA, eloB) {
-    const exponent = (eloB - eloA) / 400;
-    return 1 / (1 + Math.pow(10, exponent));
-  }
-  Elo2.getWinProbability = getWinProbability;
-  function getOutcome(eloA, eloB, kFactor = Elo2.K_FACTOR) {
-    const probA = getWinProbability(eloA, eloB);
-    const probB = 1 - probA;
-    return {
-      aWins: {
-        eloA: Math.round(eloA + kFactor * (1 - probA)),
-        eloB: Math.round(eloB + kFactor * (0 - probB))
-      },
-      bWins: {
-        eloA: Math.round(eloA + kFactor * (0 - probA)),
-        eloB: Math.round(eloB + kFactor * (1 - probB))
-      },
-      null: {
-        eloA: Math.round(eloA + kFactor * (0.5 - probA)),
-        eloB: Math.round(eloB + kFactor * (0.5 - probB))
-      }
-    };
-  }
-  Elo2.getOutcome = getOutcome;
-})(Elo || (Elo = {}));
-
-export {
-  Elo
-};

package/components/index.d.ts

@@ -1 +0,0 @@
-export declare namespace Components { }

package/node/mxfb-cli-config/index.d.ts

@@ -1,19 +0,0 @@
-export type Config = {
-    mxfb_projects_sync?: {
-        lm_path?: string;
-        mxfb_path?: string;
-    };
-};
-export declare const emptyConfigObj: Config;
-export declare function createConfigFile(force?: boolean): Promise<true | Error>;
-declare const deletionSecurityPhrase = "THIS IS A DESTRUCTIVE AND DEFINITIVE ACTION";
-export declare function deleteConfigDir(security: typeof deletionSecurityPhrase): Promise<true | Error>;
-export declare function deleteConfigFile(security: typeof deletionSecurityPhrase): Promise<true | Error>;
-export declare function ensureConfigFile(): Promise<true | Error>;
-export declare function getConfigFile(): Promise<string | Error>;
-export declare function validateConfigObj(configObj: any): configObj is Config;
-export declare function parseConfigFile(fileContents: string): Config | Error;
-export declare function getConfig(create?: boolean): Promise<Config | Error>;
-export type ConfigUpdater = Partial<Config> | ((curr: Config) => Config);
-export declare function updateConfig(updater: ConfigUpdater, create?: boolean): Promise<true | Error>;
-export {};

package/node/mxfb-cli-config/index.js

@@ -1,113 +0,0 @@
-// src/node/mxfb-cli-config/index.ts
-import os from "node:os";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-var homeDirPath = os.homedir();
-var mxfbConfigDirPath = path.join(homeDirPath, ".config/mxfb-cli");
-var mxfbConfigFilePath = path.join(mxfbConfigDirPath, "config.json");
-var emptyConfigObj = {};
-async function createConfigFile(force = false) {
-  await fs.mkdir(mxfbConfigDirPath, { recursive: true });
-  try {
-    await fs.stat(mxfbConfigFilePath);
-    if (force === true) throw "create anyway";
-    return true;
-  } catch (err) {
-    try {
-      await fs.writeFile(
-        mxfbConfigFilePath,
-        `${JSON.stringify(emptyConfigObj, null, 2)}
-`,
-        { encoding: "utf-8" }
-      );
-      return true;
-    } catch (err2) {
-      if (err2 instanceof Error) return err2;
-      if (typeof err2 === "string") return new Error(err2);
-      return new Error(`${err2}`);
-    }
-  }
-}
-var deletionSecurityPhrase = "THIS IS A DESTRUCTIVE AND DEFINITIVE ACTION";
-async function deleteConfigDir(security) {
-  if (security !== deletionSecurityPhrase) return new Error("You must provide the security phrase");
-  await fs.rm(mxfbConfigDirPath, { recursive: true, force: true });
-  return true;
-}
-async function deleteConfigFile(security) {
-  if (security !== deletionSecurityPhrase) return new Error("You must provide the security phrase");
-  await fs.rm(mxfbConfigDirPath);
-  return true;
-}
-async function ensureConfigFile() {
-  try {
-    await fs.stat(mxfbConfigFilePath);
-    return true;
-  } catch (err) {
-    try {
-      const created = await createConfigFile();
-      if (created instanceof Error) throw created;
-      return true;
-    } catch (err2) {
-      if (err2 instanceof Error) return err2;
-      if (typeof err2 === "string") return new Error(err2);
-      return new Error(`${err2}`);
-    }
-  }
-}
-async function getConfigFile() {
-  try {
-    const fileContents = await fs.readFile(mxfbConfigFilePath, { encoding: "utf-8" });
-    return fileContents;
-  } catch (err) {
-    if (err instanceof Error) return err;
-    if (typeof err === "string") return new Error(err);
-    return new Error(`${err}`);
-  }
-}
-function validateConfigObj(configObj) {
-  return true;
-}
-function parseConfigFile(fileContents) {
-  try {
-    const parsed = JSON.parse(fileContents);
-    const validated = validateConfigObj(parsed);
-    if (!validated) throw new Error(`Invalid config file shape: ${fileContents}`);
-    return parsed;
-  } catch (err) {
-    if (err instanceof Error) return err;
-    if (typeof err === "string") return new Error(err);
-    return new Error(`${err}`);
-  }
-}
-async function getConfig(create = false) {
-  if (create) {
-    const created = await ensureConfigFile();
-    if (created !== true) return created;
-  }
-  const configStr = await getConfigFile();
-  if (configStr instanceof Error) return configStr;
-  const parsed = parseConfigFile(configStr);
-  if (parsed instanceof Error) return parsed;
-  return parsed;
-}
-async function updateConfig(updater, create = false) {
-  const currentConfig = await getConfig(create);
-  if (currentConfig instanceof Error) return currentConfig;
-  const updatedConfig = typeof updater === "function" ? updater(currentConfig) : { ...currentConfig, ...updater };
-  const stringified = JSON.stringify(updatedConfig, null, 2);
-  await fs.writeFile(mxfbConfigFilePath, stringified, { encoding: "utf-8" });
-  return true;
-}
-export {
-  createConfigFile,
-  deleteConfigDir,
-  deleteConfigFile,
-  emptyConfigObj,
-  ensureConfigFile,
-  getConfig,
-  getConfigFile,
-  parseConfigFile,
-  updateConfig,
-  validateConfigObj
-};

package/shared/errors/index.d.ts

@@ -1,138 +0,0 @@
-import { Errors } from '@design-edito/tools/agnostic/errors';
-export declare enum Codes {
-    NO_DOCUMENT = "no-window-document-on-runtime",
-    NO_DOCUMENT_PLEASE_PROVIDE = "no-window-document-on-runtime-please-provide",
-    IMPOSSIBLE_TO_PICK_IN_ARRAY = "impossible-to-pick-in-array"
-}
-export declare const register: {
-    getMessage: <Code extends Codes>(code: Code) => Errors.Register.Message<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>;
-    getDetailsMaker: <Code extends Codes>(code: Code) => Errors.Register.DetailsMaker<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>;
-    getDetails: <Code extends Codes>(code: Code, ...params: Parameters<Errors.Register.DetailsMaker<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>>) => ReturnType<Errors.Register.DetailsMaker<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>>;
-    getErrorData: <Code extends Codes>(code: Code, ...params: Parameters<Errors.Register.DetailsMaker<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>>) => Errors.Register.ErrorData<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>;
-    getError: <Code extends Codes>(code: Code, ...params: Parameters<Errors.Register.DetailsMaker<{
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    }, Code>>) => {
-        code: Code;
-        details: ReturnType<Errors.Register.DetailsMaker<{
-            "no-window-document-on-runtime": {
-                message: string;
-                detailsMaker: () => undefined;
-            };
-            "no-window-document-on-runtime-please-provide": {
-                message: string;
-                detailsMaker: (tips?: string) => string | undefined;
-            };
-            "impossible-to-pick-in-array": {
-                message: string;
-                detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-            };
-        }, Code>>;
-        name: string;
-        message: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    source: {
-        "no-window-document-on-runtime": {
-            message: string;
-            detailsMaker: () => undefined;
-        };
-        "no-window-document-on-runtime-please-provide": {
-            message: string;
-            detailsMaker: (tips?: string) => string | undefined;
-        };
-        "impossible-to-pick-in-array": {
-            message: string;
-            detailsMaker: (array: any[]) => "Array cannot be empty" | "Too many exclusions";
-        };
-    };
-};