odoro 1.0.9 → 2.1.0

package/dist/{chunk-LHZGX5ML.js → chunk-HS7NGZLM.js}

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { depFileName, INTERNAL_PREFIX, DEPS_PREFIX, urlToFile, hasExtension, STYLE_EXTENSIONS, feuilleDemandee, ASSET_EXTENSIONS, wrapAsset, estUneRessource, wrapJson, SOURCE_EXTENSIONS, ecouter, fileToUrl, transformModule, wrapStyle, applyAlias, isBareSpecifier } from './chunk-TQUJ3MFS.js';
-import { info, error, warn, success, duration, colors } from './chunk-JMEHF3KN.js';
-import { existsSync, readFileSync, statSync, watch, createReadStream } from 'fs';
+import { sourcePlugin, depFileName, SOURCE_EXTENSIONS, listen, openBrowser, INTERNAL_PREFIX, applyAlias, readSuffix, hasExtension, STYLE_EXTENSIONS, ASSET_EXTENSIONS, isBareSpecifier, MIME, DEPS_PREFIX, urlToFile, wantsStylesheet, wrapAsset, isAssetRequest, wrapJson, sendFile, transformHtmlWith, textModule, urlModule, workerModule, fileToUrl, wrapStyle, transformModule } from './chunk-RTWJ5GFB.js';
+import { info, warn, success, duration, colors, error } from './chunk-7ZB5MAM6.js';
+import { existsSync, readFileSync, statSync, watch } from 'fs';
 import { readFile, rm, mkdir, writeFile } from 'fs/promises';
 import { createServer, request } from 'http';
+import { createServer as createServer$1 } from 'https';
 import { join, dirname, resolve, extname } from 'path';
 import { createRequire } from 'module';
 import { pathToFileURL, fileURLToPath } from 'url';
@@ -12,37 +13,90 @@ import { build } from 'esbuild';
 import { transformAsync } from '@babel/core';
 import reactRefreshPlugin from 'react-refresh/babel';
 
-var PAQUET = "@odoro-cli/libs";
-var SOUS_CHEMIN = "./generateur";
-function fichierDe(entree) {
-  if (entree === void 0) return void 0;
-  if (typeof entree === "string") return entree;
-  return entree.import ?? entree.default;
+var PACKAGE = "@odoro-cli/libs";
+var SUBPATH = "./generator";
+function fileFor(entry) {
+  if (entry === void 0) return void 0;
+  if (typeof entry === "string") return entry;
+  return entry.import ?? entry.default;
 }
-async function fournisseurDe(root) {
+async function cssProviderFor(root) {
   try {
-    const exiger = createRequire(join(root, "package.json"));
-    const manifeste = exiger.resolve(`${PAQUET}/package.json`);
-    const dossier = dirname(manifeste);
-    const contenu = JSON.parse(await readFile(manifeste, "utf8"));
-    const relatif = fichierDe(contenu.exports?.[SOUS_CHEMIN]);
-    if (relatif === void 0) return void 0;
-    const module_ = await import(pathToFileURL(resolve(dossier, relatif)).href);
-    if (typeof module_.renderUtilitairesPour !== "function") return void 0;
+    const require_ = createRequire(join(root, "package.json"));
+    const manifest = require_.resolve(`${PACKAGE}/package.json`);
+    const directory = dirname(manifest);
+    const content = JSON.parse(await readFile(manifest, "utf8"));
+    const relativePath = fileFor(content.exports?.[SUBPATH]);
+    if (relativePath === void 0) return void 0;
+    const module_ = await import(pathToFileURL(resolve(directory, relativePath)).href);
+    if (typeof module_.renderUtilitiesFor !== "function") return void 0;
     const generate = module_.generate;
     return {
-      renderUtilitairesPour: module_.renderUtilitairesPour,
-      // `generate` enumere les classes du palier courant. Absent d'un paquet
-      // plus ancien : le champ reste alors indefini, et le developpement
-      // retombe sur la feuille telle qu'elle est livree.
+      renderUtilitiesFor: module_.renderUtilitiesFor,
+      // `generate` enumerates the classes of the current tier. Absent from an
+      // older package: the field then stays undefined, and development falls
+      // back on the stylesheet as it ships.
       ...typeof generate === "function" ? {
-        classesConnues: () => new Set(generate("core").classNames)
+        knownClasses: () => new Set(generate("core").classNames)
       } : {}
     };
   } catch {
     return void 0;
   }
 }
+var IMPORT = /@import\s+(?:url\(\s*)?(['"])([^'"]+)\1\s*\)?\s*([^;]*);/g;
+var URL_VALUE = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
+function isExternal(address) {
+  return address.startsWith("data:") || address.startsWith("http:") || address.startsWith("https:") || address.startsWith("//") || address.startsWith("#");
+}
+function resolveReference(reference, from) {
+  if (reference.startsWith("/")) return void 0;
+  if (isBareSpecifier(reference)) {
+    try {
+      return createRequire(from).resolve(reference);
+    } catch {
+      return void 0;
+    }
+  }
+  const path = resolve(dirname(from), reference);
+  return existsSync(path) ? path : void 0;
+}
+async function assembleStylesheet(file, root) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const read = async (path) => {
+    if (seen.has(path)) return "";
+    seen.add(path);
+    files.push(path);
+    const source = await readFile(path, "utf8");
+    const pieces = [];
+    let cursor = 0;
+    for (const found of source.matchAll(IMPORT)) {
+      const reference = found[2];
+      const conditions = (found[3] ?? "").trim();
+      if (reference === void 0) continue;
+      pieces.push(source.slice(cursor, found.index));
+      cursor = found.index + found[0].length;
+      const target = isExternal(reference) ? void 0 : resolveReference(reference, path);
+      if (target === void 0) {
+        pieces.push(found[0]);
+        continue;
+      }
+      const content = await read(target);
+      pieces.push(conditions === "" ? content : `@media ${conditions} {
+${content}
+}`);
+    }
+    pieces.push(source.slice(cursor));
+    return pieces.join("").replace(URL_VALUE, (whole, quote, address) => {
+      if (isExternal(address) || address.startsWith("/")) return whole;
+      const target = resolveReference(address, path);
+      if (target === void 0) return whole;
+      return `url(${quote}${fileToUrl(target, root)}${quote})`;
+    });
+  };
+  return { css: await read(file), files };
+}
 
 // src/dev/client.ts
 var HMR_STREAM_PATH = "/@odoro/hmr";
@@ -50,23 +104,23 @@ var HMR_CLIENT_PATH = "/@odoro/client";
 var HMR_CLIENT_SOURCE = String.raw`
 const OVERLAY_ID = 'odoro-error-overlay'
 
-/** Contextes de rechargement, par URL de module. */
+/** Hot contexts, by module URL. */
 const contexts = new Map()
 
 /**
- * Cree le contexte expose a un module via import.meta.hot.
+ * Creates the context exposed to a module through import.meta.hot.
  * @param {string} url
  */
 export function createHotContext(url) {
   const existing = contexts.get(url)
   if (existing) {
-    // Rechargement du meme module : les rappels de la version precedente sont
-    // executes puis oublies.
+    // Reload of the same module: the callbacks of the previous version are run
+    // then forgotten.
     for (const callback of existing.disposers) {
       try {
         callback(existing.data)
       } catch (cause) {
-        console.error('[odoro] echec du nettoyage de', url, cause)
+        console.error('[odoro] cleanup failed for', url, cause)
       }
     }
     existing.disposers = []
@@ -96,7 +150,7 @@ export function createHotContext(url) {
 }
 
 /**
- * Recharge un module et notifie ceux qui l'acceptent.
+ * Reloads a module and notifies those that accept it.
  * @param {string} url
  * @param {number} timestamp
  */
@@ -111,20 +165,20 @@ async function applyUpdate(url, timestamp) {
   try {
     const module = await import(url + (url.includes('?') ? '&' : '?') + 't=' + timestamp)
     for (const accept of acceptors) accept(module)
-    console.log('[odoro] mis a jour', url)
+    console.log('[odoro] updated', url)
   } catch (cause) {
-    console.error('[odoro] echec de la mise a jour de', url, cause)
+    console.error('[odoro] update failed for', url, cause)
     location.reload()
   }
 }
 
-/** Retire la surcouche d'erreur si elle est affichee. */
+/** Removes the error overlay when it is displayed. */
 function clearOverlay() {
   document.getElementById(OVERLAY_ID)?.remove()
 }
 
 /**
- * Affiche une erreur de compilation par-dessus la page.
+ * Displays a build error on top of the page.
  * @param {string} message
  * @param {string | undefined} file
  */
@@ -146,14 +200,14 @@ function showOverlay(message, file) {
   ].join(';')
 
   const title = document.createElement('div')
-  title.textContent = file ? 'Erreur de compilation — ' + file : 'Erreur de compilation'
+  title.textContent = file ? 'Build error — ' + file : 'Build error'
   title.style.cssText = 'font-weight:700;margin-bottom:1rem;color:#ff9d9d'
 
   const body = document.createElement('div')
   body.textContent = message
 
   const hint = document.createElement('div')
-  hint.textContent = 'Corrigez le fichier : cette surcouche disparaitra d elle-meme.'
+  hint.textContent = 'Fix the file: this overlay will disappear on its own.'
   hint.style.cssText = 'margin-top:1.5rem;opacity:0.6'
 
   overlay.append(title, body, hint)
@@ -167,7 +221,7 @@ source.addEventListener('message', (event) => {
 
   switch (payload.type) {
     case 'connected':
-      console.log('[odoro] rechargement a chaud connecte')
+      console.log('[odoro] hot reloading connected')
       break
     case 'update':
       clearOverlay()
@@ -187,9 +241,9 @@ source.addEventListener('message', (event) => {
 })
 
 source.addEventListener('error', () => {
-  // EventSource se reconnecte seul ; on ne signale que la perte prolongee.
+  // EventSource reconnects on its own; we only report a prolonged loss.
   if (source.readyState === EventSource.CLOSED) {
-    console.warn('[odoro] connexion de rechargement perdue')
+    console.warn('[odoro] hot reloading connection lost')
   }
 })
 `.replace("__HMR_STREAM_PATH__", HMR_STREAM_PATH);
@@ -307,6 +361,9 @@ function collectBareImports(config, found) {
       builder.onResolve({ filter: /.*/ }, (args) => {
         if (args.kind === "entry-point") return null;
         const aliased = applyAlias(args.path, config);
+        if (readSuffix(aliased) !== void 0) {
+          return { path: aliased, external: true };
+        }
         if (hasExtension(aliased, STYLE_EXTENSIONS) || hasExtension(aliased, ASSET_EXTENSIONS)) {
           return { path: aliased, external: true };
         }
@@ -330,29 +387,36 @@ async function scanDependencies(config, entries) {
     logLevel: "silent",
     absWorkingDir: config.root,
     jsx: "automatic",
-    // Le serveur compile en JSX de developpement : sans ce reglage, le
-    // parcours chercherait `react/jsx-runtime` la ou le navigateur demandera
-    // `react/jsx-dev-runtime`, et la dependance manquerait a l'appel.
+    // The server compiles with the development JSX: without this setting, the
+    // scan would look for `react/jsx-runtime` where the browser will ask for
+    // `react/jsx-dev-runtime`, and the dependency would be missing.
     jsxDev: true,
-    plugins: [collectBareImports(config, found)]
+    // The same pass as the build one: a module reached by a pattern is a module
+    // of the project, and its dependencies must be prebundled like the others.
+    // Without that, a page loaded only through `import.meta.glob` would ask at
+    // runtime for a dependency the cache does not hold.
+    plugins: [
+      collectBareImports(config, found),
+      sourcePlugin({ root: config.root, plugins: config.plugins, dev: true })
+    ]
   });
   return [...found].sort();
 }
 async function optimizeDeps(config, specifiers, force = false) {
   try {
-    return await compilerDeps(config, specifiers, force);
+    return await buildDeps(config, specifiers, force);
   } catch (cause) {
-    if (!estUneCourse(cause)) throw cause;
-    await new Promise((suite) => setTimeout(suite, DELAI_COURSE));
-    return compilerDeps(config, specifiers, force);
+    if (!isRaceError(cause)) throw cause;
+    await new Promise((next) => setTimeout(next, RACE_DELAY));
+    return buildDeps(config, specifiers, force);
   }
 }
-var DELAI_COURSE = 400;
-function estUneCourse(cause) {
+var RACE_DELAY = 400;
+function isRaceError(cause) {
   const code = cause?.code;
   return code === "ENOENT" || code === "EPERM" || code === "EBUSY";
 }
-async function compilerDeps(config, specifiers, force) {
+async function buildDeps(config, specifiers, force) {
   const directory = join(config.root, "node_modules", ".odoro", "deps");
   const sorted = [...specifiers].sort();
   const hash = createHash("sha256").update(JSON.stringify(sorted)).update(await lockfileFingerprint(config.root)).update(entriesFingerprint(config.root, sorted)).update(engineVersion()).digest("hex").slice(0, 16);
@@ -381,9 +445,9 @@ async function compilerDeps(config, specifiers, force) {
       entryPoints.push({ in: proxy, out });
     }
     await build({
-      // Les noms de sortie sont imposes : un specificateur a sous-chemin
-      // produirait sinon une arborescence, et deux paquets differents
-      // pourraient se disputer le meme nom de fichier.
+      // The output names are imposed: a specifier with a subpath would
+      // otherwise produce a directory tree, and two different packages could
+      // fight over the same file name.
       entryPoints,
       bundle: true,
       format: "esm",
@@ -412,7 +476,7 @@ function engineVersion() {
       try {
         const parsed = JSON.parse(readFileSync(manifest, "utf8"));
         if (parsed.name === "odoro") {
-          cachedVersion = parsed.version ?? "inconnue";
+          cachedVersion = parsed.version ?? "unknown";
           return cachedVersion;
         }
       } catch {
@@ -423,7 +487,7 @@ function engineVersion() {
     if (parent === directory) break;
     directory = parent;
   }
-  cachedVersion = "inconnue";
+  cachedVersion = "unknown";
   return cachedVersion;
 }
 function entriesFingerprint(root, specifiers) {
@@ -449,13 +513,13 @@ function packageFingerprint(name, resolver) {
   try {
     manifestPath = resolver.resolve(`${name}/package.json`);
   } catch {
-    return "introuvable";
+    return "not-found";
   }
   let manifest;
   try {
     manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
   } catch {
-    return "illisible";
+    return "unreadable";
   }
   const directory = dirname(manifestPath);
   const targets = /* @__PURE__ */ new Set();
@@ -491,7 +555,7 @@ async function lockfileFingerprint(root) {
     if (!existsSync(file)) continue;
     return createHash("sha256").update(await readFile(file)).digest("hex");
   }
-  return "sans-verrou";
+  return "no-lockfile";
 }
 
 // src/dev/graph.ts
@@ -500,7 +564,7 @@ function detectSelfAccepting(source) {
 }
 var ModuleGraph = class {
   nodes = /* @__PURE__ */ new Map();
-  /** Recupere un module, ou le cree s'il est inconnu. */
+  /** Gets a module, or creates it when it is unknown. */
   ensure(file, url) {
     const existing = this.nodes.get(file);
     if (existing !== void 0) return existing;
@@ -516,17 +580,17 @@ var ModuleGraph = class {
     this.nodes.set(file, node);
     return node;
   }
-  /** Recupere un module deja connu. */
+  /** Gets a module already known. */
   get(file) {
     return this.nodes.get(file);
   }
-  /** Nombre de modules connus. */
+  /** Number of known modules. */
   get size() {
     return this.nodes.size;
   }
   /**
-   * Remplace la liste des dependances d'un module, en tenant a jour les
-   * relations inverses.
+   * Replaces the dependency list of a module, keeping the reverse relations up
+   * to date.
    */
   setDependencies(file, dependencies) {
     const node = this.nodes.get(file);
@@ -544,14 +608,14 @@ var ModuleGraph = class {
     }
   }
   /**
-   * Invalide un module et remonte la chaine de ses importateurs jusqu'a
-   * trouver, sur chaque branche, un module qui accepte les mises a jour.
+   * Invalidates a module and climbs the chain of its importers until it finds,
+   * on every branch, a module that accepts updates.
    *
-   * @returns Les modules a recharger cote client. Un tableau vide signifie
-   *   qu'aucune frontiere n'accepte la mise a jour : il faut recharger la page.
+   * @returns The modules to reload on the client side. An empty array means
+   *   that no boundary accepts the update: the page must be reloaded.
    *
    * @example
-   * const boundaries = graph.invalidate('/projet/src/App.css')
+   * const boundaries = graph.invalidate('/project/src/App.css')
    */
   invalidate(file) {
     const boundaries = [];
@@ -577,7 +641,7 @@ var ModuleGraph = class {
     };
     return walk(file) ? boundaries : [];
   }
-  /** Oublie tous les modules. */
+  /** Forgets every module. */
   clear() {
     this.nodes.clear();
   }
@@ -594,22 +658,22 @@ async function applyReactRefresh(code, file) {
     filename: file,
     babelrc: false,
     configFile: false,
-    // La carte de source produite par la compilation precedente est reprise et
-    // fusionnee : sans cela, les numeros de ligne du debogueur designeraient le
-    // code instrumente plutot que la source.
+    // The source map produced by the previous build is picked up and merged:
+    // without that, the line numbers in the debugger would designate the
+    // instrumented code rather than the source.
     //
-    // `true` demande a Babel de lire la carte inline du code recu. Il l'accepte
-    // — verifie : la source reprise est bien le fichier d'origine — mais les
-    // types de la 7.x ne decrivent que la forme objet. L'annotation est
-    // incomplete, pas la valeur.
+    // `true` asks Babel to read the inline map of the received code. It accepts
+    // it — checked: the source picked up is indeed the original file — but the
+    // 7.x types only describe the object form. The annotation is incomplete,
+    // not the value.
     inputSourceMap: true,
     sourceMaps: "inline",
-    // `skipEnvCheck` leve un garde-fou destine aux configurations globales,
-    // qui refuse la transformation hors de NODE_ENV=development. Ici c'est le
-    // point d'application qui garantit la regle : cette fonction n'est appelee
-    // que par le serveur de developpement, jamais par la compilation de
-    // production. Sans cela, un `NODE_ENV=production odoro dev` — ou une suite
-    // de tests — echouerait au lieu de simplement instrumenter.
+    // `skipEnvCheck` lifts a guard meant for global configurations, which
+    // refuses the transformation outside NODE_ENV=development. Here it is the
+    // point of application that enforces the rule: this function is only called
+    // by the development server, never by the production build. Without it, a
+    // `NODE_ENV=production odoro dev` — or a test suite — would fail instead of
+    // simply instrumenting.
     plugins: [[reactRefreshPlugin, { skipEnvCheck: true }]],
     parserOpts: { sourceType: "module" }
   });
@@ -635,8 +699,8 @@ void import(import.meta.url).then((__odoroCurrent) => {
   __odoroRefresh.registerExports(${JSON.stringify(id)}, __odoroCurrent)
   import.meta.hot?.accept((__odoroNext) => {
     if (!__odoroNext) return
-    const refus = __odoroRefresh.checkBoundary(__odoroCurrent, __odoroNext)
-    if (refus !== null) import.meta.hot.invalidate(refus)
+    const refusal = __odoroRefresh.checkBoundary(__odoroCurrent, __odoroNext)
+    if (refusal !== null) import.meta.hot.invalidate(refusal)
     else {
       __odoroRefresh.registerExports(${JSON.stringify(id)}, __odoroNext)
       __odoroRefresh.enqueueUpdate()
@@ -647,12 +711,12 @@ void import(import.meta.url).then((__odoroCurrent) => {
 }
 var REFRESH_RUNTIME_SOURCE = `import runtime from 'react-refresh/runtime'
 
-// Le crochet doit etre installe **avant** que React ne soit charge : c'est par
-// lui que React signale les composants qu'il rend.
+// The hook must be installed **before** React is loaded: it is through it that
+// React reports the components it renders.
 runtime.injectIntoGlobalHook(window)
 
-// Valeurs neutres : un module non instrumente doit pouvoir s'evaluer sans que
-// ces fonctions existent vraiment.
+// Neutral values: an uninstrumented module must be able to evaluate without
+// those functions really existing.
 window.$RefreshReg$ = () => {}
 window.$RefreshSig$ = () => (type) => type
 
@@ -660,11 +724,10 @@ export const register = runtime.register
 export const createSignature = runtime.createSignatureFunctionForTransform
 
 /**
- * Enregistre les exports d'un module qui ressemblent a des composants.
+ * Registers the exports of a module that look like components.
  *
- * L'enregistrement par nom d'export complete celui pose dans le corps du
- * module : un composant re-exporte depuis un autre fichier n'y apparaitrait
- * pas.
+ * Registering by export name completes the one placed in the body of the
+ * module: a component re-exported from another file would not appear there.
  */
 export function registerExports(id, exports) {
   for (const key of Object.keys(exports)) {
@@ -676,29 +739,29 @@ export function registerExports(id, exports) {
 }
 
 /**
- * Verifie qu'un module peut etre remplace a chaud.
+ * Checks that a module can be replaced hot.
  *
- * @returns null si le remplacement est sur, sinon la raison du refus.
+ * @returns null when the replacement is safe, otherwise the reason for refusal.
  */
 export function checkBoundary(previous, next) {
   const before = Object.keys(previous)
   const after = Object.keys(next)
 
-  if (after.length === 0) return 'le module n exporte plus rien'
+  if (after.length === 0) return 'the module no longer exports anything'
 
   for (const key of after) {
-    if (!before.includes(key)) return 'nouvel export : ' + key
+    if (!before.includes(key)) return 'new export: ' + key
   }
   for (const key of before) {
-    if (!after.includes(key)) return 'export retire : ' + key
+    if (!after.includes(key)) return 'export removed: ' + key
   }
 
   for (const key of after) {
     const value = next[key]
     if (runtime.isLikelyComponentType(value)) continue
-    // Un export qui n'est pas un composant ne peut etre conserve que s'il n'a
-    // pas change : sinon ses consommateurs garderaient l'ancienne valeur.
-    if (previous[key] !== value) return 'export non-composant modifie : ' + key
+    // An export that is not a component can only be kept when it has not
+    // changed: otherwise its consumers would keep the old value.
+    if (previous[key] !== value) return 'non-component export changed: ' + key
   }
 
   return null
@@ -707,7 +770,7 @@ export function checkBoundary(previous, next) {
 let planned
 const DEBOUNCE = 16
 
-/** Regroupe les mises a jour d'une meme salve en un seul rafraichissement. */
+/** Groups the updates of a same burst into a single refresh. */
 export function enqueueUpdate() {
   clearTimeout(planned)
   planned = setTimeout(() => {
@@ -740,44 +803,31 @@ async function bundleRefreshRuntime() {
 }
 
 // src/dev/server.ts
-var UTILITAIRES_PATH = `${INTERNAL_PREFIX}utilitaires.css`;
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".txt": "text/plain; charset=utf-8",
-  ".md": "text/markdown; charset=utf-8",
-  ".markdown": "text/markdown; charset=utf-8"
-};
+var UTILITIES_PATH = `${INTERNAL_PREFIX}utilities.css`;
 var SCRIPT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
 function cleanUrl(url) {
   return (url.split("?")[0] ?? url).split("#")[0] ?? url;
 }
-function buildEnv(config) {
-  const env = {
-    MODE: "development",
-    DEV: true,
-    PROD: false,
-    BASE_URL: config.base
-  };
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key.startsWith(config.envPrefix) && value !== void 0) env[key] = value;
+function suffixOf(url) {
+  const query = url.split("?")[1];
+  if (query === void 0) return void 0;
+  for (const name of ["worker", "raw", "url"]) {
+    if (query.split("&").includes(name)) return name;
   }
-  return env;
+  return void 0;
+}
+function chain(middlewares, request_, response, done) {
+  let index = 0;
+  const next = () => {
+    const middleware = middlewares[index];
+    index += 1;
+    if (middleware === void 0) {
+      done();
+      return;
+    }
+    void (async () => middleware(request_, response, next))();
+  };
+  next();
 }
 function extractEntries(html, root) {
   const entries = [];
@@ -790,11 +840,11 @@ function extractEntries(html, root) {
   }
   return entries;
 }
-function injectClient(html, utilitaires = false) {
+function injectClient(html, utilities = false) {
   const tags = [
-    // La feuille vient avant tout le reste : le socle et les styles de
-    // l'application, importes ensuite, doivent pouvoir la surcharger.
-    ...utilitaires ? [`<link rel="stylesheet" href="${UTILITAIRES_PATH}">`] : [],
+    // The stylesheet comes before everything else: the base and the application
+    // styles, imported afterwards, must be able to override it.
+    ...utilities ? [`<link rel="stylesheet" href="${UTILITIES_PATH}">`] : [],
     REFRESH_HTML_TAG,
     `<script type="module" src="${HMR_CLIENT_PATH}"></script>`
   ].join("\n    ");
@@ -806,25 +856,37 @@ ${html}`;
 async function startDevServer(config) {
   const started = Date.now();
   const graph = new ModuleGraph();
-  const env = buildEnv(config);
+  const env = config.envClient;
   const clients = /* @__PURE__ */ new Set();
+  const middlewares = [];
+  for (const plugin of config.plugins) {
+    await plugin.configureServer?.({
+      use: (middleware) => middlewares.push(middleware)
+    });
+  }
   const indexFile = join(config.root, "index.html");
   if (!existsSync(indexFile)) {
-    throw new Error(`[odoro] Aucun "index.html" a la racine du projet (${config.root}).`);
+    throw new Error(`[odoro] No "index.html" at the project root (${config.root}).`);
   }
   const refreshRuntime = await bundleRefreshRuntime();
-  const fournisseur = await fournisseurDe(config.root);
-  const utilitaires = fournisseur?.classesConnues === void 0 ? void 0 : fournisseur.renderUtilitairesPour(fournisseur.classesConnues());
-  if (utilitaires !== void 0) {
+  const provider = await cssProviderFor(config.root);
+  const utilities = provider?.knownClasses === void 0 ? void 0 : provider.renderUtilitiesFor(provider.knownClasses());
+  if (utilities !== void 0) {
+    info(`development utilities: ${String(Math.round(utilities.length / 1024))} kB`);
+  }
+  const exposed = Object.keys(config.envClient).filter(
+    (key) => key.startsWith(config.envPrefix)
+  );
+  if (exposed.length > 0) {
     info(
-      `utilitaires de developpement : ${String(Math.round(utilitaires.length / 1024))} Ko`
+      `${String(exposed.length)} variable${exposed.length > 1 ? "s" : ""} exposed to the client: ${exposed.join(", ")}`
     );
   }
   const entries = extractEntries(await readFile(indexFile, "utf8"), config.root);
   const specifiers = await scanDependencies(config, entries);
   const deps = await optimizeDeps(config, specifiers);
   if (deps.rebuilt && specifiers.length > 0) {
-    info(`${specifiers.length} dependances pre-compilees`);
+    info(`${specifiers.length} dependencies prebundled`);
   }
   const broadcast = (message) => {
     const payload = `data: ${JSON.stringify(message)}
@@ -860,40 +922,63 @@ async function startDevServer(config) {
       }
       node.code = hotPreamble(url2) + body;
     }
-    send(response, node.code, MIME[".js"]);
+    send(response, node.code, MIME[".js"] ?? "text/javascript");
   };
   const serveStyle = async (response, file, direct) => {
-    const css = await readFile(file, "utf8");
+    const { css, files } = await assembleStylesheet(file, config.root);
     if (direct) {
-      send(response, css, MIME[".css"]);
+      send(response, css, MIME[".css"] ?? "text/css");
       return;
     }
     const url2 = fileToUrl(file, config.root);
     const node = graph.ensure(file, url2);
     node.selfAccepting = true;
     node.code = hotPreamble(url2) + wrapStyle(url2, css);
-    send(response, node.code, MIME[".js"]);
+    const imported = files.filter((one) => one !== file);
+    if (imported.length > 0) {
+      graph.setDependencies(file, imported);
+      for (const one of imported) {
+        const dependency = graph.ensure(one, fileToUrl(one, config.root));
+        dependency.importers.add(file);
+        dependency.selfAccepting = false;
+      }
+    }
+    send(response, node.code, MIME[".js"] ?? "text/javascript");
+  };
+  const serveSuffixed = async (response, file, path, suffix) => {
+    if (suffix === "raw") {
+      send(
+        response,
+        textModule(await readFile(file, "utf8")),
+        MIME[".js"] ?? "text/javascript"
+      );
+      return;
+    }
+    if (suffix === "url") {
+      send(response, urlModule(path), MIME[".js"] ?? "text/javascript");
+      return;
+    }
+    send(response, workerModule(path), MIME[".js"] ?? "text/javascript");
   };
-  const indexDeDossier = (dossier) => {
-    if (!existsSync(dossier) || !statSync(dossier).isDirectory()) return void 0;
-    for (const nom of ["index.html", "index.md"]) {
-      const candidat = join(dossier, nom);
-      if (existsSync(candidat) && statSync(candidat).isFile()) return candidat;
+  const directoryIndex = (directory) => {
+    if (!existsSync(directory) || !statSync(directory).isDirectory()) return void 0;
+    for (const name of ["index.html", "index.md"]) {
+      const candidate = join(directory, name);
+      if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
     }
     return void 0;
   };
-  const serveFile = (response, file) => {
-    const type = MIME[extname(file).toLowerCase()] ?? "application/octet-stream";
-    response.writeHead(200, { "Content-Type": type, "Cache-Control": "no-cache" });
-    createReadStream(file).pipe(response);
+  const serveFile = (response, file, incoming) => {
+    sendFile(response, file, { range: incoming?.headers.range });
   };
-  const serveHtml = async (response) => {
+  const serveHtml = async (response, route = "/") => {
     const html = await readFile(indexFile, "utf8");
-    send(
-      response,
-      injectClient(html, utilitaires !== void 0),
-      MIME[".html"]
+    const rendered = await transformHtmlWith(
+      config.plugins,
+      injectClient(html, utilities !== void 0),
+      { dev: true, route }
     );
+    send(response, rendered, MIME[".html"] ?? "text/html");
   };
   const forward = (incoming, response, target) => {
     const url2 = new URL(incoming.url ?? "/", target);
@@ -912,12 +997,12 @@ async function startDevServer(config) {
       }
     );
     proxied.on("error", (cause) => {
-      warn(`proxy indisponible : ${target}`);
-      send(response, `Proxy indisponible : ${String(cause)}`, "text/plain", 502);
+      warn(`proxy unavailable: ${target}`);
+      send(response, `Proxy unavailable: ${String(cause)}`, "text/plain", 502);
     });
     incoming.pipe(proxied);
   };
-  const server = createServer((incoming, response) => {
+  const handle = (incoming, response) => {
     void (async () => {
       const url2 = incoming.url ?? "/";
       const path = cleanUrl(url2);
@@ -932,12 +1017,12 @@ async function startDevServer(config) {
           send(response, refreshRuntime, MIME[".js"] ?? "text/javascript");
           return;
         }
-        if (path === UTILITAIRES_PATH) {
-          if (utilitaires === void 0) {
-            send(response, "Introuvable", "text/plain", 404);
+        if (path === UTILITIES_PATH) {
+          if (utilities === void 0) {
+            send(response, "Not found", "text/plain", 404);
             return;
           }
-          send(response, utilitaires, MIME[".css"] ?? "text/css");
+          send(response, utilities, MIME[".css"] ?? "text/css");
           return;
         }
         if (path === HMR_CLIENT_PATH) {
@@ -963,13 +1048,13 @@ async function startDevServer(config) {
           const name = last.endsWith(".js") ? last : depFileName(last);
           const file2 = join(deps.directory, name);
           if (existsSync(file2)) {
-            serveFile(response, file2);
+            serveFile(response, file2, incoming);
             return;
           }
           send(
             response,
             `throw new Error(${JSON.stringify(
-              `[odoro] Dependance non pre-compilee : "${specifier}". Relancez le serveur.`
+              `[odoro] Dependency not prebundled: "${specifier}". Restart the server.`
             )})`,
             MIME[".js"] ?? "text/javascript"
           );
@@ -980,20 +1065,25 @@ async function startDevServer(config) {
           return;
         }
         if (path.startsWith(INTERNAL_PREFIX)) {
-          send(response, "Introuvable", "text/plain", 404);
+          send(response, "Not found", "text/plain", 404);
           return;
         }
         const file = urlToFile(path, config.root);
         if (existsSync(file) && statSync(file).isFile()) {
+          const suffix = suffixOf(url2);
+          if (suffix !== void 0) {
+            await serveSuffixed(response, file, path, suffix);
+            return;
+          }
           if (hasExtension(path, STYLE_EXTENSIONS)) {
-            await serveStyle(response, file, feuilleDemandee(incoming.headers, url2));
+            await serveStyle(response, file, wantsStylesheet(incoming.headers, url2));
             return;
           }
           if (hasExtension(path, ASSET_EXTENSIONS)) {
             if (url2.includes("?import")) {
               send(response, wrapAsset(path), MIME[".js"] ?? "text/javascript");
             } else {
-              serveFile(response, file);
+              serveFile(response, file, incoming);
             }
             return;
           }
@@ -1002,40 +1092,56 @@ async function startDevServer(config) {
             return;
           }
           if (hasExtension(path, [".json"])) {
-            if (estUneRessource(incoming.headers) || url2.includes("?import")) {
+            if (isAssetRequest(incoming.headers) || url2.includes("?import")) {
               const json = await readFile(file, "utf8");
               send(response, wrapJson(json), MIME[".js"] ?? "text/javascript");
             } else {
-              serveFile(response, file);
+              serveFile(response, file, incoming);
             }
             return;
           }
-          serveFile(response, file);
+          serveFile(response, file, incoming);
           return;
         }
         const publicFile = join(config.publicDir, path.replace(/^\//, ""));
         if (existsSync(publicFile) && statSync(publicFile).isFile()) {
-          serveFile(response, publicFile);
+          serveFile(response, publicFile, incoming);
           return;
         }
-        const index = indexDeDossier(publicFile);
+        const index = directoryIndex(publicFile);
         if (index !== void 0) {
-          serveFile(response, index);
+          serveFile(response, index, incoming);
           return;
         }
-        if (!extname(path) && !estUneRessource(incoming.headers)) {
-          await serveHtml(response);
+        if (!extname(path) && !isAssetRequest(incoming.headers)) {
+          await serveHtml(response, path);
           return;
         }
-        send(response, "Introuvable", "text/plain", 404);
+        send(response, "Not found", "text/plain", 404);
       } catch (cause) {
         const message = cause instanceof Error ? cause.message : String(cause);
-        error(`echec du traitement de ${path}`, cause);
+        error(`failed to handle ${path}`, cause);
         broadcast({ type: "error", message, file: path });
-        send(response, `Erreur : ${message}`, "text/plain", 500);
+        send(response, `Error: ${message}`, "text/plain", 500);
       }
     })();
-  });
+  };
+  const listener = (incoming, response) => {
+    if (middlewares.length === 0) {
+      handle(incoming, response);
+      return;
+    }
+    chain(middlewares, incoming, response, () => {
+      handle(incoming, response);
+    });
+  };
+  const server = config.server.https === void 0 ? createServer(listener) : createServer$1(
+    {
+      cert: readFileSync(resolve(config.root, config.server.https.cert)),
+      key: readFileSync(resolve(config.root, config.server.https.key))
+    },
+    listener
+  );
   let pending;
   const changed = /* @__PURE__ */ new Set();
   const watcher = watch(config.root, { recursive: true }, (_event, filename) => {
@@ -1071,23 +1177,28 @@ async function startDevServer(config) {
         }
       }
       if (reload) {
-        info("rechargement de la page");
+        info("page reload");
         broadcast({ type: "full-reload" });
       } else if (updates.length > 0) {
-        info(
-          `mise a jour a chaud : ${updates.map((update) => update.url).join(", ")}`
-        );
+        info(`hot update: ${updates.map((update) => update.url).join(", ")}`);
         broadcast({ type: "update", updates });
       }
     }, 40);
   });
-  const { port, demande } = await ecouter(server, config.server.port, config.server.host);
-  if (demande !== void 0) {
-    warn(`port ${String(demande)} occupe \u2014 le serveur ecoute sur ${String(port)}`);
+  const { port, requested } = await listen(
+    server,
+    config.server.port,
+    config.server.host,
+    config.server.strictPort ? 1 : void 0
+  );
+  if (requested !== void 0) {
+    warn(`port ${String(requested)} in use \u2014 server listening on ${String(port)}`);
   }
-  const url = `http://${config.server.host}:${String(port)}${config.base}`;
-  success(`pret en ${duration(Date.now() - started)}`);
+  const protocol = config.server.https === void 0 ? "http" : "https";
+  const url = `${protocol}://${config.server.host}:${String(port)}${config.base}`;
+  success(`ready in ${duration(Date.now() - started)}`);
   info(`  ${colors.cyan(url)}`);
+  if (config.server.open) openBrowser(url);
   return {
     url,
     async close() {
@@ -1101,4 +1212,4 @@ async function startDevServer(config) {
   };
 }
 
-export { ModuleGraph, detectSelfAccepting, extractEntries, fournisseurDe, injectClient, optimizeDeps, scanDependencies, startDevServer };
+export { ModuleGraph, cssProviderFor, detectSelfAccepting, extractEntries, injectClient, optimizeDeps, scanDependencies, startDevServer };