@jsarc/pajo 0.0.0 → 0.0.1-beta.0.1

package/README.md

@@ -73,7 +73,7 @@ const { Pajo } = require('@jsarc/pajo');
 ```html
 <script src="@jsarc/pajo/pajo.all.js"></script>
 <script>
-  // Disponible globalement via window.Pajo
+  // Disponible globalement via (window as any).Pajo
   console.log(Pajo.join('path', 'to', 'file.txt'));
 </script>
 ```
@@ -247,7 +247,7 @@ Expose la classe Pajo à l'objet global (window) pour une utilisation dans les n
 ```javascript
 // Dans un navigateur, après avoir chargé le script
 Pajo.exposeToGlobal();
-console.log(window.Pajo); // La classe Pajo est disponible
+console.log((window as any).Pajo); // La classe Pajo est disponible
 ```
 
 ## 🔧 Utilisation Détaillée

package/index.ts

@@ -215,7 +215,7 @@ const globalFunct = (function(global: any) {
 
         static exposeToGlobal(): void {
             if (typeof window !== "undefined") {
-                window.Pajo = Pajo;
+                (window as any).Pajo = Pajo;
             }
         }
     }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0",
+  "version": "0.0.1-beta.0.1",
   "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.ts",
   "keywords": [],

package/pajo.ts

@@ -0,0 +1,271 @@
+// @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 as any).Pajo = Pajo;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        Pajo.exposeToGlobal();
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: Pajo,
+        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 exports !== 'undefined') {
+        exports.default = Pajo;
+        exports.Pajo = Pajo;
+    }
+	return globalFunctModule;
+
+})(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;
+
+
+

package/ts/index.ts

@@ -0,0 +1,277 @@
+// @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 as any).Pajo = Pajo;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        Pajo.exposeToGlobal();
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: Pajo,
+        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 exports !== 'undefined') {
+        exports.default = Pajo;
+        exports.Pajo = Pajo;
+    }
+	return globalFunctModule;
+
+})(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 {
+	defaultElementGF as default,
+	PajoElementGF as Pajo,
+};
+export type {
+	DefaultElementTypeGF,
+	PajoElementTypeGF,
+};

package/ts/pajo.ts

@@ -0,0 +1,271 @@
+// @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 as any).Pajo = Pajo;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        Pajo.exposeToGlobal();
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: Pajo,
+        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 exports !== 'undefined') {
+        exports.default = Pajo;
+        exports.Pajo = Pajo;
+    }
+	return globalFunctModule;
+
+})(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;
+
+
+