@arc-js/pajo 0.0.0

package/README.md

@@ -0,0 +1,568 @@
+# @arc-js/pajo
+
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-007ACC)
+![Browser](https://img.shields.io/badge/browser-compatible-green)
+![Node.js](https://img.shields.io/badge/Node.js-18+-339933)
+![Deno](https://img.shields.io/badge/Deno-1.30+-000000)
+![Bun](https://img.shields.io/badge/Bun-1.0+-FBF0DF)
+
+**@arc-js/pajo** est une bibliothèque TypeScript légère et robuste pour la manipulation de chemins de fichiers et d'URLs. Elle offre une API unifiée et type-safe pour travailler avec des chemins de fichiers sur différentes plateformes (Windows, Linux, macOS) et pour construire des URLs de manière cohérente.
+
+## ✨ Fonctionnalités Principales
+
+### 📁 Manipulation de Chemins
+- **Style multi-plateforme** : Support natif des chemins Windows (\) et Unix (/)
+- **Joindre des chemins** : Méthode intelligente pour joindre plusieurs segments de chemin
+- **Chemins absolus/relatifs** : Détection automatique du type de chemin
+- **Normalisation** : Élimination des séparateurs redondants et des points (., ..)
+- **Extraction** : Récupération du nom de fichier, extension et répertoire parent
+
+### 🌐 Manipulation d'URLs
+- **Construction d'URLs** : Joindre des segments avec un hôte (avec ou sans protocole)
+- **Normalisation automatique** : Ajout de protocole si absent, gestion des slashs
+- **Support des protocoles** : Reconnaissance automatique des schémas (http://, https://, etc.)
+
+### 🔄 Conversion
+- **Conversion de style** : Convertir entre chemins Windows et Unix
+- **Adaptation automatique** : Détection du style basée sur le contenu du chemin
+
+### 🛡️ Robustesse
+- **Gestion des cas limites** : Chemins vides, séparateurs multiples, points spéciaux
+- **Type-safe** : Entièrement écrit en TypeScript avec des types stricts
+- **Pas de dépendances** : Bibliothèque autonome, zéro dépendance
+
+## 📦 Installation
+
+### Via npm/yarn/pnpm
+
+```bash
+npm install @arc-js/pajo
+# ou
+yarn add @arc-js/pajo
+# ou
+pnpm add @arc-js/pajo
+```
+
+### Importation directe (CDN)
+
+```html
+<script src="@arc-js/pajo/pajo.all.js"></script>
+```
+
+## 🚀 Démarrage Rapide
+
+### TypeScript/ES Modules
+
+```typescript
+import Pajo from '@arc-js/pajo';
+// ou
+import { Pajo } from '@arc-js/pajo';
+```
+
+### CommonJS
+
+```javascript
+const Pajo = require('@arc-js/pajo').default;
+// ou
+const { Pajo } = require('@arc-js/pajo');
+```
+
+### Navigateur (global)
+
+```html
+<script src="@arc-js/pajo/pajo.all.js"></script>
+<script>
+  // Disponible globalement via window.Pajo
+  console.log(Pajo.join('path', 'to', 'file.txt'));
+</script>
+```
+
+### Deno
+
+```typescript
+import Pajo from '@arc-js/pajo';
+```
+
+## 📚 Documentation API
+
+### Méthodes Statiques
+
+#### `Pajo.join(...paths: string[]): string | undefined`
+Joint plusieurs segments de chemin en normalisant les séparateurs.
+
+**Paramètres:**
+- `paths`: Segments de chemin à joindre (peut être vide)
+
+**Retourne:** Le chemin normalisé ou `undefined` si aucun chemin valide
+
+**Exemples:**
+```typescript
+// Chemins Unix
+Pajo.join('/var', 'www', 'html');           // "/var/www/html"
+Pajo.join('/usr/', '/local/', '/bin');      // "/usr/local/bin"
+Pajo.join('./src', './utils', '../components'); // "src/components"
+
+// Chemins Windows
+Pajo.join('C:\\Users', 'Documents', 'file.txt'); // "C:\\Users\\Documents\\file.txt"
+Pajo.join('D:\\Projects\\', '\\src\\', '\\app.js'); // "D:\\Projects\\src\\app.js"
+
+// Chemins mixtes
+Pajo.join('path', 'to', 'file.txt');        // "path/to/file.txt"
+Pajo.join('path/', '//to/', 'file.txt');    // "path/to/file.txt"
+```
+
+#### `Pajo.joinWithHost(host: string, ...paths: string[]): string | undefined`
+Joint un hôte avec des segments de chemin pour former une URL.
+
+**Paramètres:**
+- `host`: Hôte (peut inclure le protocole)
+- `paths`: Segments de chemin à joindre
+
+**Retourne:** L'URL complète normalisée ou `undefined` si invalide
+
+**Exemples:**
+```typescript
+Pajo.joinWithHost('example.com', 'api', 'v1', 'users'); 
+// "https://example.com/api/v1/users"
+
+Pajo.joinWithHost('https://example.com', 'api', 'v1'); 
+// "https://example.com/api/v1"
+
+Pajo.joinWithHost('myserver.com', '/var', 'log', 'app.log'); 
+// "https://myserver.com/var/log/app.log"
+```
+
+#### `Pajo.resolve(...paths: string[]): string | undefined`
+Résout les chemins avec . et .. pour obtenir un chemin normalisé.
+
+**Paramètres:**
+- `paths`: Segments de chemin à résoudre
+
+**Retourne:** Chemin résolu ou `undefined` si invalide
+
+**Exemples:**
+```typescript
+Pajo.resolve('/foo/bar', './baz');          // "/foo/bar/baz"
+Pajo.resolve('/foo/bar', '../baz');         // "/foo/baz"
+Pajo.resolve('C:\\foo\\bar', '..\\baz'); // "C:\\foo\\baz"
+```
+
+#### `Pajo.isAbsolute(path: string): boolean`
+Vérifie si un chemin est absolu.
+
+**Paramètres:**
+- `path`: Chemin à vérifier
+
+**Retourne:** `true` si le chemin est absolu
+
+**Exemples:**
+```typescript
+Pajo.isAbsolute('/path/to/file');           // true
+Pajo.isAbsolute('C:\\Windows\\System32'); // true
+Pajo.isAbsolute('https://example.com');     // true
+Pajo.isAbsolute('relative/path');           // false
+Pajo.isAbsolute('./file.txt');              // false
+```
+
+#### `Pajo.dirname(path: string): string | undefined`
+Extrait le répertoire parent d'un chemin.
+
+**Paramètres:**
+- `path`: Chemin source
+
+**Retourne:** Le répertoire parent ou `undefined`
+
+**Exemples:**
+```typescript
+Pajo.dirname('/path/to/file.txt');          // "/path/to"
+Pajo.dirname('C:\\Users\\file.txt');      // "C:\\Users"
+Pajo.dirname('file.txt');                   // "."
+```
+
+#### `Pajo.basename(path: string, ext?: string): string | undefined`
+Extrait le nom de fichier d'un chemin.
+
+**Paramètres:**
+- `path`: Chemin source
+- `ext` (optionnel): Extension à retirer
+
+**Retourne:** Le nom de fichier ou `undefined`
+
+**Exemples:**
+```typescript
+Pajo.basename('/path/to/file.txt');         // "file.txt"
+Pajo.basename('/path/to/file.txt', '.txt'); // "file"
+Pajo.basename('C:\\Users\\document.pdf'); // "document.pdf"
+```
+
+#### `Pajo.extname(path: string): string | undefined`
+Extrait l'extension d'un fichier.
+
+**Paramètres:**
+- `path`: Chemin source
+
+**Retourne:** L'extension (incluant le point) ou `undefined`
+
+**Exemples:**
+```typescript
+Pajo.extname('/path/to/file.txt');          // ".txt"
+Pajo.extname('document.pdf');               // ".pdf"
+Pajo.extname('file.with.many.dots.tar.gz'); // ".gz"
+Pajo.extname('noextension');                // undefined
+```
+
+#### `Pajo.toUnixPath(path: string): string`
+Convertit un chemin Windows en chemin Unix.
+
+**Paramètres:**
+- `path`: Chemin Windows
+
+**Retourne:** Chemin Unix
+
+**Exemples:**
+```typescript
+Pajo.toUnixPath('C:\\Users\\file.txt');   // "C:/Users/file.txt"
+Pajo.toUnixPath('D:\\Projects\\src');     // "D:/Projects/src"
+```
+
+#### `Pajo.toWindowsPath(path: string): string`
+Convertit un chemin Unix en chemin Windows.
+
+**Paramètres:**
+- `path`: Chemin Unix
+
+**Retourne:** Chemin Windows
+
+**Exemples:**
+```typescript
+Pajo.toWindowsPath('/home/user/file.txt');  // "\\home\\user\\file.txt"
+Pajo.toWindowsPath('C:/Users/document');    // "C:\\Users\\document"
+```
+
+#### `Pajo.exposeToGlobal(): void`
+Expose la classe Pajo à l'objet global (window) pour une utilisation dans les navigateurs.
+
+**Exemple:**
+```javascript
+// Dans un navigateur, après avoir chargé le script
+Pajo.exposeToGlobal();
+console.log(window.Pajo); // La classe Pajo est disponible
+```
+
+## 🔧 Utilisation Détaillée
+
+### Gestion Multi-Plateforme
+
+Pajo détecte automatiquement le style de chemin basé sur le contenu :
+
+```typescript
+// Détection automatique du style
+Pajo.join('C:\\Users', 'Documents');      // Style Windows
+Pajo.join('/home', 'user');                 // Style Unix
+Pajo.join('relative', 'path');              // Style Unix par défaut
+```
+
+### Construction d'URLs
+
+```typescript
+// Construction d'URLs avec protocole automatique
+Pajo.joinWithHost('api.example.com', 'v1', 'users');
+// → "https://api.example.com/v1/users"
+
+// Avec protocole explicite
+Pajo.joinWithHost('http://localhost:3000', 'api', 'data');
+// → "http://localhost:3000/api/data"
+
+// Avec chemin absolu sur l'hôte
+Pajo.joinWithHost('example.com', '/absolute/path');
+// → "https://example.com/absolute/path"
+```
+
+### Résolution de Chemins Relatifs
+
+```typescript
+// Résolution des chemins avec .. et .
+Pajo.resolve('/usr/local/bin', '..', 'share');
+// → "/usr/local/share"
+
+Pajo.resolve('C:\\Program Files\\App', '..', 'Common Files');
+// → "C:\\Program Files\\Common Files"
+
+Pajo.resolve('./src', '../lib', './utils');
+// → "lib/utils"
+```
+
+### Extraction d'Informations
+
+```typescript
+const path = '/var/www/html/index.html';
+
+Pajo.dirname(path);    // "/var/www/html"
+Pajo.basename(path);   // "index.html"
+Pajo.extname(path);    // ".html"
+Pajo.isAbsolute(path); // true
+```
+
+## 🎯 Exemples Complets
+
+### Exemple 1 : Gestion de Chemins dans une Application
+
+```typescript
+import Pajo from '@arc-js/pajo';
+
+class FileManager {
+  private baseDir: string;
+  
+  constructor(baseDir: string) {
+    this.baseDir = baseDir;
+  }
+  
+  getFilePath(...segments: string[]): string {
+    const fullPath = Pajo.join(this.baseDir, ...segments);
+    return Pajo.resolve(fullPath) || fullPath;
+  }
+  
+  getFileInfo(path: string) {
+    return {
+      directory: Pajo.dirname(path),
+      filename: Pajo.basename(path),
+      extension: Pajo.extname(path),
+      isAbsolute: Pajo.isAbsolute(path),
+      unixPath: Pajo.toUnixPath(path)
+    };
+  }
+}
+
+// Utilisation
+const manager = new FileManager('/var/www');
+const filePath = manager.getFilePath('uploads', '..', 'images', 'photo.jpg');
+console.log(filePath); // "/var/images/photo.jpg"
+
+const info = manager.getFileInfo(filePath);
+console.log(info);
+// {
+//   directory: "/var/images",
+//   filename: "photo.jpg",
+//   extension: ".jpg",
+//   isAbsolute: true,
+//   unixPath: "/var/images/photo.jpg"
+// }
+```
+
+### Exemple 2 : Construction d'APIs REST
+
+```typescript
+import Pajo from '@arc-js/pajo';
+
+class ApiClient {
+  private baseUrl: string;
+  
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+  
+  buildUrl(endpoint: string, ...params: string[]): string {
+    return Pajo.joinWithHost(this.baseUrl, endpoint, ...params) || '';
+  }
+  
+  async getResource(endpoint: string, id?: string) {
+    const url = id 
+      ? this.buildUrl(endpoint, id)
+      : this.buildUrl(endpoint);
+    
+    const response = await fetch(url);
+    return response.json();
+  }
+}
+
+// Utilisation
+const api = new ApiClient('https://api.example.com');
+
+// Construire des URLs
+const usersUrl = api.buildUrl('users'); 
+// → "https://api.example.com/users"
+
+const userUrl = api.buildUrl('users', '123');
+// → "https://api.example.com/users/123"
+
+// Récupérer des données
+const users = await api.getResource('users');
+const user = await api.getResource('users', '123');
+```
+
+### Exemple 3 : Migration Multi-Plateforme
+
+```typescript
+import Pajo from '@arc-js/pajo';
+
+function migratePath(oldPath: string, newBase: string): string {
+  // Normaliser le chemin d'entrée
+  const normalized = Pajo.resolve(oldPath);
+  if (!normalized) return newBase;
+  
+  // Extraire le nom de fichier
+  const filename = Pajo.basename(normalized);
+  
+  // Construire le nouveau chemin
+  return Pajo.join(newBase, filename);
+}
+
+// Migration depuis Windows vers Unix
+const windowsPath = 'C:\\Users\\John\\Documents\\file.txt';
+const unixBase = '/home/john/files';
+
+const migrated = migratePath(windowsPath, unixBase);
+console.log(migrated); // "/home/john/files/file.txt"
+
+// Conversion explicite si nécessaire
+console.log(Pajo.toUnixPath(windowsPath)); // "C:/Users/John/Documents/file.txt"
+```
+
+## 🔧 Configuration Avancée
+
+### Personnalisation du Style de Chemin
+
+Bien que Pajo détecte automatiquement le style, vous pouvez forcer un style spécifique :
+
+```typescript
+function forceWindowsPath(...segments: string[]): string {
+  // Ajouter un préfixe Windows pour forcer le style
+  return Pajo.join('C:\\forced', ...segments).replace('C:\\forced\\', '');
+}
+
+function forceUnixPath(...segments: string[]): string {
+  // Ajouter un slash initial pour forcer le style Unix
+  return Pajo.join('/forced', ...segments).replace('/forced/', '');
+}
+```
+
+### Extension pour les Chemins d'URL
+
+```typescript
+class UrlPath extends Pajo {
+  static normalizeUrlPath(path: string): string {
+    // Pour les URLs, on utilise toujours des slashs
+    return path.replace(/\\/g, '/').replace(/\/+/g, '/');
+  }
+  
+  static buildQueryString(params: Record<string, any>): string {
+    const query = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        query.append(key, String(value));
+      }
+    });
+    const queryString = query.toString();
+    return queryString ? `?\${queryString}` : '';
+  }
+  
+  static joinWithQuery(host: string, path: string, queryParams?: Record<string, any>): string {
+    const url = this.joinWithHost(host, path);
+    if (!url || !queryParams) return url || '';
+    
+    const query = this.buildQueryString(queryParams);
+    return `\${url}\${query}`;
+  }
+}
+
+// Utilisation
+const url = UrlPath.joinWithQuery(
+  'example.com',
+  'api/search',
+  { q: 'test', page: 1 }
+);
+console.log(url); // "https://example.com/api/search?q=test&page=1"
+```
+
+## 📋 Table de Compatibilité
+
+### Caractères Spéciaux Supportés
+
+| Caractère | Description | Exemple |
+|-----------|-------------|---------|
+| . | Répertoire courant | `./file.txt` |
+| .. | Répertoire parent | `../parent/file.txt` |
+| ~ | Répertoire home (Unix) | `~/.config/app` |
+| \\ | Séparateur Windows | `C:\\Users\\file.txt` |
+| / | Séparateur Unix | `/home/user/file.txt` |
+
+### Plates-formes Supportées
+
+| Plate-forme | Support | Notes |
+|-------------|---------|-------|
+| Windows | ✅ Complet | Détection automatique des chemins Windows |
+| Linux | ✅ Complet | Détection automatique des chemins Unix |
+| macOS | ✅ Complet | Identique à Linux |
+| Navigateurs | ✅ Complet | Via CDN ou module ES |
+| Node.js | ✅ Complet | v18+ recommandé |
+| Deno | ✅ Complet | Via esm.sh ou npm: |
+| Bun | ✅ Complet | Support natif des modules ES |
+
+## 🚨 Gestion des Cas Limites
+
+### Chemins Vides ou Nuls
+
+```typescript
+Pajo.join();                    // undefined
+Pajo.join('');                  // undefined
+Pajo.join('', 'path');          // "path"
+Pajo.join('path', '', 'file');  // "path/file"
+```
+
+### Séparateurs Multiples
+
+```typescript
+Pajo.join('path///', '//to/', 'file.txt');  // "path/to/file.txt"
+Pajo.join('C:\\\\Windows', '\\\\System32'); // "C:\\\\Windows\\\\System32"
+```
+
+### Chemins avec Points
+
+```typescript
+Pajo.join('..', 'parent', 'file.txt');     // "../parent/file.txt"
+Pajo.join('.', 'current', 'file.txt');     // "current/file.txt"
+Pajo.join('path..', 'file.txt');           // "path../file.txt"
+```
+
+### URLs et Protocoles
+
+```typescript
+Pajo.joinWithHost('https://example.com');  // "https://example.com"
+Pajo.joinWithHost('ftp://server.com', 'files'); // "ftp://server.com/files"
+Pajo.joinWithHost('file:///C:/Users', 'doc.txt'); // "file:///C:/Users/doc.txt"
+```
+
+## 🔧 Build et Développement
+
+### Structure du Projet
+
+```
+@arc-js/pajo/
+├── pajo.all.js
+├── pajo.all.min.js
+├── index.d.ts
+├── index.js
+├── index.min.d.ts
+├── index.min.js
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## 📄 Licence
+
+MIT License - Voir le fichier [LICENSE](LICENSE) pour plus de détails.
+
+## 🐛 Signaler un Bug
+
+Envoyez nous un mail à l'adresse `contact.inicode@gmail.com` pour :
+- Signaler un bug
+- Proposer une amélioration
+- Poser une question
+
+---
+
+**@arc-js/pajo** - Manipulation de chemins multi-plateforme, simple et robuste.
+
+*Développé par l'équipe INICODE*

package/index.ts

@@ -0,0 +1,294 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Pajo: any;
+    __bundledModules: any;
+}
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+
+
+    class Pajo {
+        private static readonly PROTOCOL_REGEX = new RegExp('^[a-zA-Z]+://');
+        private static readonly DOUBLE_SLASH_REGEX = new RegExp('/+', 'g');
+        private static readonly DOUBLE_BACKSLASH_REGEX = new RegExp('\\\\+', 'g');
+        private static readonly TRAILING_SLASH_REGEX = new RegExp('/+$');
+        private static readonly TRAILING_BACKSLASH_REGEX = new RegExp('\\\\+$');
+        private static readonly LEADING_SLASH_REGEX = new RegExp('^/+');
+        private static readonly WINDOWS_DRIVE_REGEX = new RegExp('^[a-zA-Z]:\\\\');
+        private static readonly MIXED_SEPARATORS_REGEX = new RegExp('[\\\\/]+', 'g');
+
+        /**
+         * Joint plusieurs segments de chemin en normalisant les séparateurs
+         * @param paths Segments de chemin à joindre
+         * @returns Le chemin normalisé ou undefined si aucun chemin valide
+         */
+        static join(...paths: string[]): string | undefined {
+            if (paths.length === 0) return undefined;
+
+            // Détection du style de chemin (Windows ou Unix)
+            const isWindowsPath = paths.some(path => this.isWindowsPath(path));
+
+            // Filtre les chemins vides et nettoie chaque segment
+            const cleanPaths = paths
+                .filter(path => path != null && path.trim().length > 0)
+                .map(path => this.normalizePathSegment(path, isWindowsPath));
+
+            if (cleanPaths.length === 0) return undefined;
+
+            // Reconstruction du chemin final avec le séparateur approprié
+            const separator = isWindowsPath ? '\\' : '/';
+            let result = cleanPaths.join(separator);
+
+            if (isWindowsPath) {
+                result = result.replace(this.DOUBLE_BACKSLASH_REGEX, '\\');
+            } else {
+                result = result.replace(this.DOUBLE_SLASH_REGEX, '/');
+
+                // Préservation du slash initial pour les chemins absolus Linux
+                const hasLeadingSlash = paths[0]?.startsWith('/') || false;
+                if (hasLeadingSlash && !result.startsWith('/')) {
+                    result = '/' + result;
+                }
+            }
+
+            return result || undefined;
+        }
+
+        /**
+         * Joint un hôte avec des segments de chemin
+         * @param host Hôte (peut inclure le protocole)
+         * @param paths Segments de chemin à joindre
+         * @returns L'URL complète normalisée ou undefined si invalide
+         */
+        static joinWithHost(host: string, ...paths: string[]): string | undefined {
+            if (!host || host.trim().length === 0) {
+                return this.join(...paths);
+            }
+
+            const cleanHost = host.trim().replace(this.TRAILING_SLASH_REGEX, '');
+
+            const hasProtocol = this.PROTOCOL_REGEX.test(cleanHost);
+            const normalizedHost = hasProtocol ? cleanHost : `https://${cleanHost}`;
+
+            const joinedPath = this.join(...paths);
+            if (!joinedPath) {
+                return normalizedHost;
+            }
+
+            const cleanPath = joinedPath.replace(new RegExp('\\\\', 'g'), '/').replace(this.LEADING_SLASH_REGEX, '');
+            return `${normalizedHost}/${cleanPath}`;
+        }
+
+        /**
+         * Normalise un segment de chemin individuel
+         * @param path Segment de chemin à normaliser
+         * @param isWindowsStyle Si on doit utiliser le style Windows
+         * @returns Le segment normalisé
+         */
+        private static normalizePathSegment(path: string, isWindowsStyle: boolean): string {
+            if (!path || path.trim().length === 0) return '';
+
+            const trimmed = path.trim();
+
+            if (isWindowsStyle) {
+                return trimmed
+                    .replace(this.DOUBLE_BACKSLASH_REGEX, '\\')
+                    .replace(this.TRAILING_BACKSLASH_REGEX, '');
+            } else {
+                return trimmed
+                    .replace(this.DOUBLE_SLASH_REGEX, '/')
+                    .replace(this.TRAILING_SLASH_REGEX, '');
+            }
+        }
+
+        private static isWindowsPath(path: string): boolean {
+            return this.WINDOWS_DRIVE_REGEX.test(path) || path.includes('\\');
+        }
+
+        /**
+         * Résout les chemins avec . et .. (simplifié)
+         * @param paths Segments de chemin à résoudre
+         * @returns Chemin résolu
+         */
+        static resolve(...paths: string[]): string | undefined {
+            const joined = this.join(...paths);
+            if (!joined) return undefined;
+
+            const isWindows = this.isWindowsPath(joined);
+            const separator = isWindows ? '\\' : '/';
+            const parts = joined.split(separator);
+            const resolved: string[] = [];
+
+            for (const part of parts) {
+                if (part === '..') {
+                    if (resolved.length > 0 && resolved[resolved.length - 1] !== '..') {
+                        resolved.pop();
+                    } else {
+                        resolved.push(part);
+                    }
+                } else if (part !== '.' && part !== '') {
+                    resolved.push(part);
+                }
+            }
+
+            let result = resolved.join(separator);
+
+            if (isWindows && this.WINDOWS_DRIVE_REGEX.test(parts[0])) {
+                result = parts[0] + separator + result;
+            }
+
+            return result;
+        }
+
+        static isAbsolute(path: string): boolean {
+            if (!path) return false;
+
+            return path.startsWith('/') ||
+                this.WINDOWS_DRIVE_REGEX.test(path) ||
+                this.PROTOCOL_REGEX.test(path);
+        }
+
+        static dirname(path: string): string | undefined {
+            if (!path) return undefined;
+
+            const isWindows = this.isWindowsPath(path);
+            const separator = isWindows ? '\\' : '/';
+            const normalized = this.normalizePathSegment(path, isWindows);
+            const lastSeparatorIndex = normalized.lastIndexOf(separator);
+
+            if (lastSeparatorIndex === -1) return isWindows ? '.' : '.';
+            if (lastSeparatorIndex === 0) return isWindows ? normalized.substring(0, 2) : '/';
+
+            return normalized.substring(0, lastSeparatorIndex) || (isWindows ? '.' : '/');
+        }
+
+        /**
+         * Extrait le nom de fichier d'un chemin
+         * @param path Chemin source
+         * @param ext Extension optionnelle à retirer
+         * @returns Le nom de fichier ou undefined
+         */
+        static basename(path: string, ext?: string): string | undefined {
+            if (!path) return undefined;
+
+            const isWindows = this.isWindowsPath(path);
+            const separator = isWindows ? '\\' : '/';
+            const normalized = this.normalizePathSegment(path, isWindows);
+            const lastSeparatorIndex = normalized.lastIndexOf(separator);
+            let basename = lastSeparatorIndex === -1 ? normalized : normalized.substring(lastSeparatorIndex + 1);
+
+            // Gestion de l'extension optionnelle
+            if (ext && basename.endsWith(ext)) {
+                basename = basename.substring(0, basename.length - ext.length);
+            }
+
+            return basename || undefined;
+        }
+
+        static extname(path: string): string | undefined {
+            if (!path) return undefined;
+
+            const basename = this.basename(path);
+            if (!basename) return undefined;
+
+            const lastDotIndex = basename.lastIndexOf('.');
+            return lastDotIndex > 0 ? basename.substring(lastDotIndex) : undefined;
+        }
+
+        static toUnixPath(path: string): string {
+            return path.replace(new RegExp('\\\\', 'g'), '/');
+        }
+
+        /**
+         * Convertit un chemin Unix en chemin Windows
+         * @param path Chemin Unix
+         * @returns Chemin Windows
+         */
+        static toWindowsPath(path: string): string {
+            return path.replace(new RegExp('/', 'g'), '\\\\');
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                window.Pajo = Pajo;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        Pajo.exposeToGlobal();
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: Pajo,
+        Pajo: Pajo,
+    };
+    
+    globalFunctModule.default = {...(globalFunctModule?.default || {}), Pajo: Pajo};
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = Pajo;
+        (global as any).Pajo = Pajo;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = Pajo;
+        (window as any).Pajo = Pajo;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = __bundledModules;
+        module.exports.default = Pajo;
+        module.exports.Pajo = Pajo;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = Pajo;
+        exports.Pajo = Pajo;
+    }
+	return __bundledModules;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type PajoElementTypeGF = typeof globalFunct.Pajo;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const PajoElementGF: PajoElementTypeGF = globalFunct.Pajo;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+export {
+	PajoElementGF as Pajo,
+};
+
+export default defaultElementGF;
+if (typeof module !== 'undefined' && module.exports) {
+	module.exports = {
+		Pajo: PajoElementGF,
+	};
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+	module.exports.default = globalFunct?.default;
+}
+
+export type { PajoElementTypeGF };
+
+export type { DefaultElementTypeGF };

package/js/index.js

@@ -0,0 +1,231 @@
+const globalFunct = (function (global) {
+    'use strict';
+    class Pajo {
+        static PROTOCOL_REGEX = new RegExp('^[a-zA-Z]+://');
+        static DOUBLE_SLASH_REGEX = new RegExp('/+', 'g');
+        static DOUBLE_BACKSLASH_REGEX = new RegExp('\\\\+', 'g');
+        static TRAILING_SLASH_REGEX = new RegExp('/+$');
+        static TRAILING_BACKSLASH_REGEX = new RegExp('\\\\+$');
+        static LEADING_SLASH_REGEX = new RegExp('^/+');
+        static WINDOWS_DRIVE_REGEX = new RegExp('^[a-zA-Z]:\\\\');
+        static MIXED_SEPARATORS_REGEX = new RegExp('[\\\\/]+', 'g');
+        /**
+         * Joint plusieurs segments de chemin en normalisant les séparateurs
+         * @param paths Segments de chemin à joindre
+         * @returns Le chemin normalisé ou undefined si aucun chemin valide
+         */
+        static join(...paths) {
+            if (paths.length === 0)
+                return undefined;
+            // Détection du style de chemin (Windows ou Unix)
+            const isWindowsPath = paths.some(path => this.isWindowsPath(path));
+            // Filtre les chemins vides et nettoie chaque segment
+            const cleanPaths = paths
+                .filter(path => path != null && path.trim().length > 0)
+                .map(path => this.normalizePathSegment(path, isWindowsPath));
+            if (cleanPaths.length === 0)
+                return undefined;
+            // Reconstruction du chemin final avec le séparateur approprié
+            const separator = isWindowsPath ? '\\' : '/';
+            let result = cleanPaths.join(separator);
+            if (isWindowsPath) {
+                result = result.replace(this.DOUBLE_BACKSLASH_REGEX, '\\');
+            }
+            else {
+                result = result.replace(this.DOUBLE_SLASH_REGEX, '/');
+                // Préservation du slash initial pour les chemins absolus Linux
+                const hasLeadingSlash = paths[0]?.startsWith('/') || false;
+                if (hasLeadingSlash && !result.startsWith('/')) {
+                    result = '/' + result;
+                }
+            }
+            return result || undefined;
+        }
+        /**
+         * Joint un hôte avec des segments de chemin
+         * @param host Hôte (peut inclure le protocole)
+         * @param paths Segments de chemin à joindre
+         * @returns L'URL complète normalisée ou undefined si invalide
+         */
+        static joinWithHost(host, ...paths) {
+            if (!host || host.trim().length === 0) {
+                return this.join(...paths);
+            }
+            const cleanHost = host.trim().replace(this.TRAILING_SLASH_REGEX, '');
+            const hasProtocol = this.PROTOCOL_REGEX.test(cleanHost);
+            const normalizedHost = hasProtocol ? cleanHost : `https://${cleanHost}`;
+            const joinedPath = this.join(...paths);
+            if (!joinedPath) {
+                return normalizedHost;
+            }
+            const cleanPath = joinedPath.replace(new RegExp('\\\\', 'g'), '/').replace(this.LEADING_SLASH_REGEX, '');
+            return `${normalizedHost}/${cleanPath}`;
+        }
+        /**
+         * Normalise un segment de chemin individuel
+         * @param path Segment de chemin à normaliser
+         * @param isWindowsStyle Si on doit utiliser le style Windows
+         * @returns Le segment normalisé
+         */
+        static normalizePathSegment(path, isWindowsStyle) {
+            if (!path || path.trim().length === 0)
+                return '';
+            const trimmed = path.trim();
+            if (isWindowsStyle) {
+                return trimmed
+                    .replace(this.DOUBLE_BACKSLASH_REGEX, '\\')
+                    .replace(this.TRAILING_BACKSLASH_REGEX, '');
+            }
+            else {
+                return trimmed
+                    .replace(this.DOUBLE_SLASH_REGEX, '/')
+                    .replace(this.TRAILING_SLASH_REGEX, '');
+            }
+        }
+        static isWindowsPath(path) {
+            return this.WINDOWS_DRIVE_REGEX.test(path) || path.includes('\\');
+        }
+        /**
+         * Résout les chemins avec . et .. (simplifié)
+         * @param paths Segments de chemin à résoudre
+         * @returns Chemin résolu
+         */
+        static resolve(...paths) {
+            const joined = this.join(...paths);
+            if (!joined)
+                return undefined;
+            const isWindows = this.isWindowsPath(joined);
+            const separator = isWindows ? '\\' : '/';
+            const parts = joined.split(separator);
+            const resolved = [];
+            for (const part of parts) {
+                if (part === '..') {
+                    if (resolved.length > 0 && resolved[resolved.length - 1] !== '..') {
+                        resolved.pop();
+                    }
+                    else {
+                        resolved.push(part);
+                    }
+                }
+                else if (part !== '.' && part !== '') {
+                    resolved.push(part);
+                }
+            }
+            let result = resolved.join(separator);
+            if (isWindows && this.WINDOWS_DRIVE_REGEX.test(parts[0])) {
+                result = parts[0] + separator + result;
+            }
+            return result;
+        }
+        static isAbsolute(path) {
+            if (!path)
+                return false;
+            return path.startsWith('/') ||
+                this.WINDOWS_DRIVE_REGEX.test(path) ||
+                this.PROTOCOL_REGEX.test(path);
+        }
+        static dirname(path) {
+            if (!path)
+                return undefined;
+            const isWindows = this.isWindowsPath(path);
+            const separator = isWindows ? '\\' : '/';
+            const normalized = this.normalizePathSegment(path, isWindows);
+            const lastSeparatorIndex = normalized.lastIndexOf(separator);
+            if (lastSeparatorIndex === -1)
+                return isWindows ? '.' : '.';
+            if (lastSeparatorIndex === 0)
+                return isWindows ? normalized.substring(0, 2) : '/';
+            return normalized.substring(0, lastSeparatorIndex) || (isWindows ? '.' : '/');
+        }
+        /**
+         * Extrait le nom de fichier d'un chemin
+         * @param path Chemin source
+         * @param ext Extension optionnelle à retirer
+         * @returns Le nom de fichier ou undefined
+         */
+        static basename(path, ext) {
+            if (!path)
+                return undefined;
+            const isWindows = this.isWindowsPath(path);
+            const separator = isWindows ? '\\' : '/';
+            const normalized = this.normalizePathSegment(path, isWindows);
+            const lastSeparatorIndex = normalized.lastIndexOf(separator);
+            let basename = lastSeparatorIndex === -1 ? normalized : normalized.substring(lastSeparatorIndex + 1);
+            // Gestion de l'extension optionnelle
+            if (ext && basename.endsWith(ext)) {
+                basename = basename.substring(0, basename.length - ext.length);
+            }
+            return basename || undefined;
+        }
+        static extname(path) {
+            if (!path)
+                return undefined;
+            const basename = this.basename(path);
+            if (!basename)
+                return undefined;
+            const lastDotIndex = basename.lastIndexOf('.');
+            return lastDotIndex > 0 ? basename.substring(lastDotIndex) : undefined;
+        }
+        static toUnixPath(path) {
+            return path.replace(new RegExp('\\\\', 'g'), '/');
+        }
+        /**
+         * Convertit un chemin Unix en chemin Windows
+         * @param path Chemin Unix
+         * @returns Chemin Windows
+         */
+        static toWindowsPath(path) {
+            return path.replace(new RegExp('/', 'g'), '\\\\');
+        }
+        static exposeToGlobal() {
+            if (typeof window !== "undefined") {
+                window.Pajo = Pajo;
+            }
+        }
+    }
+    if (typeof window !== "undefined") {
+        Pajo.exposeToGlobal();
+    }
+    const globalFunctModule = {
+        default: Pajo,
+        Pajo: Pajo,
+    };
+    globalFunctModule.default = { ...(globalFunctModule?.default || {}), Pajo: Pajo };
+    const __bundledModules = globalFunctModule;
+    if (typeof global !== 'undefined') {
+        global.default = Pajo;
+        global.Pajo = Pajo;
+        global.__bundledModules = __bundledModules;
+    }
+    if (typeof window !== "undefined") {
+        window.default = Pajo;
+        window.Pajo = Pajo;
+        window.__bundledModules = __bundledModules;
+    }
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = __bundledModules;
+        module.exports.default = Pajo;
+        module.exports.Pajo = Pajo;
+    }
+    if (typeof exports !== 'undefined') {
+        exports.default = Pajo;
+        exports.Pajo = Pajo;
+    }
+    return __bundledModules;
+})(typeof global !== 'undefined' ? global :
+    typeof window !== 'undefined' ? window :
+        typeof self !== 'undefined' ? self :
+            typeof globalThis !== 'undefined' ? globalThis :
+                {});
+const PajoElementGF = globalFunct.Pajo;
+const defaultElementGF = globalFunct.default;
+export { PajoElementGF as Pajo, };
+export default defaultElementGF;
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        Pajo: PajoElementGF,
+    };
+}
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports.default = globalFunct?.default;
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@arc-js/pajo",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "description": "Pajo est une bibliothèque TypeScript légère et robuste pour la manipulation de chemins de fichiers et d'URLs. Elle offre une API unifiée et type-safe pour travailler avec des chemins de fichiers sur différentes plateformes (Windows, Linux, macOS) et pour construire des URLs de manière cohérente.",
+  "main": "index.js",
+  "keywords": [],
+  "author": "INICODE <contact.inicode@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "init": "npm init --scope=@arc-js/pajo",
+    "login": "npm login"
+  },
+  "devDependencies": {},
+  "dependencies": {}
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM", "DOM.Iterable", "ESNext"],
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": false,
+        "sourceMap": false,
+        "allowSyntheticDefaultImports": true,
+        "noEmit": false,
+        
+        "strict": false,
+        "noImplicitAny": false,
+        "strictNullChecks": false,
+        "strictFunctionTypes": false,
+        "strictBindCallApply": false,
+        "strictPropertyInitialization": false,
+        "noImplicitThis": false,
+        "alwaysStrict": false
+    },
+    "include": [],
+    "exclude": [
+        "node_modules",
+        "**/*.d.ts"
+    ]
+}

package/web/pajo.js

@@ -0,0 +1,229 @@
+const globalFunct = (function (global) {
+    'use strict';
+    class Pajo {
+        static PROTOCOL_REGEX = new RegExp('^[a-zA-Z]+://');
+        static DOUBLE_SLASH_REGEX = new RegExp('/+', 'g');
+        static DOUBLE_BACKSLASH_REGEX = new RegExp('\\\\+', 'g');
+        static TRAILING_SLASH_REGEX = new RegExp('/+$');
+        static TRAILING_BACKSLASH_REGEX = new RegExp('\\\\+$');
+        static LEADING_SLASH_REGEX = new RegExp('^/+');
+        static WINDOWS_DRIVE_REGEX = new RegExp('^[a-zA-Z]:\\\\');
+        static MIXED_SEPARATORS_REGEX = new RegExp('[\\\\/]+', 'g');
+        /**
+         * Joint plusieurs segments de chemin en normalisant les séparateurs
+         * @param paths Segments de chemin à joindre
+         * @returns Le chemin normalisé ou undefined si aucun chemin valide
+         */
+        static join(...paths) {
+            if (paths.length === 0)
+                return undefined;
+            // Détection du style de chemin (Windows ou Unix)
+            const isWindowsPath = paths.some(path => this.isWindowsPath(path));
+            // Filtre les chemins vides et nettoie chaque segment
+            const cleanPaths = paths
+                .filter(path => path != null && path.trim().length > 0)
+                .map(path => this.normalizePathSegment(path, isWindowsPath));
+            if (cleanPaths.length === 0)
+                return undefined;
+            // Reconstruction du chemin final avec le séparateur approprié
+            const separator = isWindowsPath ? '\\' : '/';
+            let result = cleanPaths.join(separator);
+            if (isWindowsPath) {
+                result = result.replace(this.DOUBLE_BACKSLASH_REGEX, '\\');
+            }
+            else {
+                result = result.replace(this.DOUBLE_SLASH_REGEX, '/');
+                // Préservation du slash initial pour les chemins absolus Linux
+                const hasLeadingSlash = paths[0]?.startsWith('/') || false;
+                if (hasLeadingSlash && !result.startsWith('/')) {
+                    result = '/' + result;
+                }
+            }
+            return result || undefined;
+        }
+        /**
+         * Joint un hôte avec des segments de chemin
+         * @param host Hôte (peut inclure le protocole)
+         * @param paths Segments de chemin à joindre
+         * @returns L'URL complète normalisée ou undefined si invalide
+         */
+        static joinWithHost(host, ...paths) {
+            if (!host || host.trim().length === 0) {
+                return this.join(...paths);
+            }
+            const cleanHost = host.trim().replace(this.TRAILING_SLASH_REGEX, '');
+            const hasProtocol = this.PROTOCOL_REGEX.test(cleanHost);
+            const normalizedHost = hasProtocol ? cleanHost : `https://${cleanHost}`;
+            const joinedPath = this.join(...paths);
+            if (!joinedPath) {
+                return normalizedHost;
+            }
+            const cleanPath = joinedPath.replace(new RegExp('\\\\', 'g'), '/').replace(this.LEADING_SLASH_REGEX, '');
+            return `${normalizedHost}/${cleanPath}`;
+        }
+        /**
+         * Normalise un segment de chemin individuel
+         * @param path Segment de chemin à normaliser
+         * @param isWindowsStyle Si on doit utiliser le style Windows
+         * @returns Le segment normalisé
+         */
+        static normalizePathSegment(path, isWindowsStyle) {
+            if (!path || path.trim().length === 0)
+                return '';
+            const trimmed = path.trim();
+            if (isWindowsStyle) {
+                return trimmed
+                    .replace(this.DOUBLE_BACKSLASH_REGEX, '\\')
+                    .replace(this.TRAILING_BACKSLASH_REGEX, '');
+            }
+            else {
+                return trimmed
+                    .replace(this.DOUBLE_SLASH_REGEX, '/')
+                    .replace(this.TRAILING_SLASH_REGEX, '');
+            }
+        }
+        static isWindowsPath(path) {
+            return this.WINDOWS_DRIVE_REGEX.test(path) || path.includes('\\');
+        }
+        /**
+         * Résout les chemins avec . et .. (simplifié)
+         * @param paths Segments de chemin à résoudre
+         * @returns Chemin résolu
+         */
+        static resolve(...paths) {
+            const joined = this.join(...paths);
+            if (!joined)
+                return undefined;
+            const isWindows = this.isWindowsPath(joined);
+            const separator = isWindows ? '\\' : '/';
+            const parts = joined.split(separator);
+            const resolved = [];
+            for (const part of parts) {
+                if (part === '..') {
+                    if (resolved.length > 0 && resolved[resolved.length - 1] !== '..') {
+                        resolved.pop();
+                    }
+                    else {
+                        resolved.push(part);
+                    }
+                }
+                else if (part !== '.' && part !== '') {
+                    resolved.push(part);
+                }
+            }
+            let result = resolved.join(separator);
+            if (isWindows && this.WINDOWS_DRIVE_REGEX.test(parts[0])) {
+                result = parts[0] + separator + result;
+            }
+            return result;
+        }
+        static isAbsolute(path) {
+            if (!path)
+                return false;
+            return path.startsWith('/') ||
+                this.WINDOWS_DRIVE_REGEX.test(path) ||
+                this.PROTOCOL_REGEX.test(path);
+        }
+        static dirname(path) {
+            if (!path)
+                return undefined;
+            const isWindows = this.isWindowsPath(path);
+            const separator = isWindows ? '\\' : '/';
+            const normalized = this.normalizePathSegment(path, isWindows);
+            const lastSeparatorIndex = normalized.lastIndexOf(separator);
+            if (lastSeparatorIndex === -1)
+                return isWindows ? '.' : '.';
+            if (lastSeparatorIndex === 0)
+                return isWindows ? normalized.substring(0, 2) : '/';
+            return normalized.substring(0, lastSeparatorIndex) || (isWindows ? '.' : '/');
+        }
+        /**
+         * Extrait le nom de fichier d'un chemin
+         * @param path Chemin source
+         * @param ext Extension optionnelle à retirer
+         * @returns Le nom de fichier ou undefined
+         */
+        static basename(path, ext) {
+            if (!path)
+                return undefined;
+            const isWindows = this.isWindowsPath(path);
+            const separator = isWindows ? '\\' : '/';
+            const normalized = this.normalizePathSegment(path, isWindows);
+            const lastSeparatorIndex = normalized.lastIndexOf(separator);
+            let basename = lastSeparatorIndex === -1 ? normalized : normalized.substring(lastSeparatorIndex + 1);
+            // Gestion de l'extension optionnelle
+            if (ext && basename.endsWith(ext)) {
+                basename = basename.substring(0, basename.length - ext.length);
+            }
+            return basename || undefined;
+        }
+        static extname(path) {
+            if (!path)
+                return undefined;
+            const basename = this.basename(path);
+            if (!basename)
+                return undefined;
+            const lastDotIndex = basename.lastIndexOf('.');
+            return lastDotIndex > 0 ? basename.substring(lastDotIndex) : undefined;
+        }
+        static toUnixPath(path) {
+            return path.replace(new RegExp('\\\\', 'g'), '/');
+        }
+        /**
+         * Convertit un chemin Unix en chemin Windows
+         * @param path Chemin Unix
+         * @returns Chemin Windows
+         */
+        static toWindowsPath(path) {
+            return path.replace(new RegExp('/', 'g'), '\\\\');
+        }
+        static exposeToGlobal() {
+            if (typeof window !== "undefined") {
+                window.Pajo = Pajo;
+            }
+        }
+    }
+    if (typeof window !== "undefined") {
+        Pajo.exposeToGlobal();
+    }
+    const globalFunctModule = {
+        default: Pajo,
+        Pajo: Pajo,
+    };
+    globalFunctModule.default = { ...(globalFunctModule?.default || {}), Pajo: Pajo };
+    const __bundledModules = globalFunctModule;
+    if (typeof global !== 'undefined') {
+        global.default = Pajo;
+        global.Pajo = Pajo;
+        global.__bundledModules = __bundledModules;
+    }
+    if (typeof window !== "undefined") {
+        window.default = Pajo;
+        window.Pajo = Pajo;
+        window.__bundledModules = __bundledModules;
+    }
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = __bundledModules;
+        module.exports.default = Pajo;
+        module.exports.Pajo = Pajo;
+    }
+    if (typeof exports !== 'undefined') {
+        exports.default = Pajo;
+        exports.Pajo = Pajo;
+    }
+    return __bundledModules;
+})(typeof global !== 'undefined' ? global :
+    typeof window !== 'undefined' ? window :
+        typeof self !== 'undefined' ? self :
+            typeof globalThis !== 'undefined' ? globalThis :
+                {});
+const PajoElementGF = globalFunct.Pajo;
+const defaultElementGF = globalFunct.default;
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        Pajo: PajoElementGF,
+    };
+}
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports.default = globalFunct?.default;
+}

package/web/pajo.min.js

@@ -0,0 +1 @@
+let globalFunct=(t=>{class e{static PROTOCOL_REGEX=new RegExp("^[a-zA-Z]+://");static DOUBLE_SLASH_REGEX=new RegExp("/+","g");static DOUBLE_BACKSLASH_REGEX=new RegExp("\\\\+","g");static TRAILING_SLASH_REGEX=new RegExp("/+$");static TRAILING_BACKSLASH_REGEX=new RegExp("\\\\+$");static LEADING_SLASH_REGEX=new RegExp("^/+");static WINDOWS_DRIVE_REGEX=new RegExp("^[a-zA-Z]:\\\\");static MIXED_SEPARATORS_REGEX=new RegExp("[\\\\/]+","g");static join(...i){if(0!==i.length){let e=i.some(t=>this.isWindowsPath(t));var s=i.filter(t=>null!=t&&0<t.trim().length).map(t=>this.normalizePathSegment(t,e));if(0!==s.length){var n=e?"\\":"/";let t=s.join(n);return e?t=t.replace(this.DOUBLE_BACKSLASH_REGEX,"\\"):(t=t.replace(this.DOUBLE_SLASH_REGEX,"/"),i[0]?.startsWith("/")&&!t.startsWith("/")&&(t="/"+t)),t||void 0}}}static joinWithHost(t,...e){var i;return t&&0!==t.trim().length?(t=t.trim().replace(this.TRAILING_SLASH_REGEX,""),t=this.PROTOCOL_REGEX.test(t)?t:"https: