@jsarc/qust 0.0.0 → 0.0.1-beta.0.1

package/README.md

@@ -328,18 +328,18 @@ const url = buildSearchUrl("/products", filters);
 
 ```typescript
 // Dans une application web
-const currentQuery = window.location.search;
+const currentQuery = (window as any).location.search;
 const params = qust.parse(currentQuery);
 
 // Utilisation avec React/Vue/Angular
 function useQueryParams() {
   const [params, setParams] = useState(() => {
-    return qust.parse(window.location.search);
+    return qust.parse((window as any).location.search);
   });
 
   const updateParams = (newParams: any) => {
     const query = qust.stringify({ ...params, ...newParams });
-    window.history.pushState({}, '', `?\${query}`);
+    (window as any).history.pushState({}, '', `?\${query}`);
     setParams(qust.parse(query));
   };
 
@@ -376,11 +376,11 @@ class FormState {
       skipEmptyString: true,
       skipNull: true
     });
-    window.location.hash = query;
+    (window as any).location.hash = query;
   }
 
   loadFromUrl() {
-    const query = window.location.hash.substring(1);
+    const query = (window as any).location.hash.substring(1);
     this.state = qust.parse(`?\${query}`) || {};
   }
 }

package/index.ts

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

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0",
+  "version": "0.0.1-beta.0.1",
   "description": "Qust est une bibliothèque TypeScript ultra-légère et performante pour la sérialisation et désérialisation d'objets en chaînes de requête (query strings). Elle offre une API simple et puissante pour manipuler les paramètres d'URL avec support des types complexes, des tableaux, des objets imbriqués et des options avancées.",
   "main": "index.ts",
   "keywords": [],

package/qust.ts

@@ -0,0 +1,429 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Qust: any;
+    qust: any;
+    __bundledModules: any;
+}
+
+interface QustOptions {
+    arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'none';
+    arraySeparator?: string;
+    skipNull?: boolean;
+    skipEmptyString?: boolean;
+    encode?: boolean;
+    decode?: boolean;
+    depth?: number;
+}
+
+
+type Primitive = string | number | boolean | null | undefined;
+
+type QueryValue = Primitive | Primitive[] | { [key: string]: QueryValue };
+
+type QueryObject = { [key: string]: QueryValue };
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+
+
+
+
+
+
+
+    const DEFAULT_OPTIONS: Required<QustOptions> = {
+        arrayFormat: 'bracket',
+        arraySeparator: ',',
+        skipNull: true,
+        skipEmptyString: false,
+        encode: true,
+        decode: true,
+        depth: 10
+    };
+
+    class Qust {
+        private options: Required<QustOptions>;
+
+        constructor(options: QustOptions = {}) {
+            this.options = { ...DEFAULT_OPTIONS, ...options };
+        }
+
+        stringify(obj: QueryObject): string {
+            if (!obj || typeof obj !== 'object') {
+                return '';
+            }
+
+            const parts: string[] = [];
+            this.processObject('', obj, parts, 0);
+
+            return parts.length > 0 ? `?${parts.join('&')}` : '';
+        }
+
+        parse<T = QueryObject>(queryString: string): T {
+            if (!queryString || typeof queryString !== 'string') {
+                return {} as T;
+            }
+
+            const cleanString = queryString.startsWith('?')
+                ? queryString.slice(1)
+                : queryString;
+
+            if (!cleanString) {
+                return {} as T;
+            }
+
+            const result: QueryObject = {};
+            const pairs = cleanString.split('&');
+
+            for (const pair of pairs) {
+                if (!pair) continue;
+
+                const [encodedKey, encodedValue] = pair.split('=');
+
+                if (!encodedKey) continue;
+
+                const key = this.options.decode
+                    ? decodeURIComponent(encodedKey)
+                    : encodedKey;
+
+                const value = this.options.decode && encodedValue !== undefined
+                    ? decodeURIComponent(encodedValue)
+                    : encodedValue;
+
+                this.setValue(result, key, value);
+            }
+
+            return this.transformArrays(result) as T;
+        }
+
+        private processObject(
+            prefix: string,
+            value: QueryValue,
+            parts: string[],
+            depth: number
+        ): void {
+            if (depth > this.options.depth) {
+                console.warn('Qust: Profondeur maximale atteinte, arrêt de la récursion');
+                return;
+            }
+
+            if (value === null || value === undefined) {
+                if (!this.options.skipNull) {
+                    parts.push(this.encodeKey(prefix));
+                }
+                return;
+            }
+
+            if (typeof value === 'string' && value === '' && this.options.skipEmptyString) {
+                return;
+            }
+
+            if (Array.isArray(value)) {
+                this.processArray(prefix, value, parts, depth + 1);
+                return;
+            }
+
+            if (typeof value === 'object' && !this.isPrimitive(value)) {
+                for (const [key, val] of Object.entries(value)) {
+                    const newPrefix = prefix ? `${prefix}[${key}]` : key;
+                    this.processObject(newPrefix, val, parts, depth + 1);
+                }
+                return;
+            }
+
+            const encodedKey = this.encodeKey(prefix);
+            const encodedValue = this.options.encode && typeof value === 'string'
+                ? encodeURIComponent(value)
+                : String(value);
+
+            parts.push(`${encodedKey}=${encodedValue}`);
+        }
+
+        private processArray(
+            prefix: string,
+            array: Primitive[],
+            parts: string[],
+            depth: number
+        ): void {
+            if (array.length === 0) return;
+
+            const encodedKey = this.encodeKey(prefix);
+
+            switch (this.options.arrayFormat) {
+                case 'comma':
+                    const values = array
+                        .map(item => this.options.encode && typeof item === 'string'
+                            ? encodeURIComponent(item)
+                            : String(item)
+                        )
+                        .join(this.options.arraySeparator);
+                    parts.push(`${encodedKey}=${values}`);
+                    break;
+
+                case 'index':
+                    array.forEach((item, index) => {
+                        const arrayPrefix = `${prefix}[${index}]`;
+                        this.processObject(arrayPrefix, item, parts, depth);
+                    });
+                    break;
+
+                case 'separator':
+                    array.forEach(item => {
+                        const encodedValue = this.options.encode && typeof item === 'string'
+                            ? encodeURIComponent(item)
+                            : String(item);
+                        parts.push(`${encodedKey}=${encodedValue}`);
+                    });
+                    break;
+
+                case 'none':
+                    array.forEach(item => {
+                        this.processObject(prefix, item, parts, depth);
+                    });
+                    break;
+
+                case 'bracket':
+                default:
+                    array.forEach(item => {
+                        const arrayPrefix = `${prefix}[]`;
+                        this.processObject(arrayPrefix, item, parts, depth);
+                    });
+                    break;
+            }
+        }
+
+        private encodeKey(key: string): string {
+            if (!this.options.encode) {
+                return key;
+            }
+
+            const parts: string[] = [];
+            let currentPart = '';
+
+            for (let i = 0; i < key.length; i++) {
+                const char = key[i];
+
+                if (char === '[' || char === ']') {
+
+                    if (currentPart) {
+                        parts.push(encodeURIComponent(currentPart));
+                        currentPart = '';
+                    }
+
+                    parts.push(char);
+                } else {
+                    currentPart += char;
+                }
+            }
+
+            if (currentPart) {
+                parts.push(encodeURIComponent(currentPart));
+            }
+
+            return parts.join('');
+        }
+
+        private setValue(obj: QueryObject, key: string, value: string | undefined): void {
+            const matches = key.match(/([^\[\]]+)|(\[\])/g);
+
+            if (!matches) {
+                if (value !== undefined) {
+                    obj[key] = this.parseValue(value);
+                }
+                return;
+            }
+
+            let current: any = obj;
+
+            for (let i = 0; i < matches.length; i++) {
+                const match = matches[i];
+                const isLast = i === matches.length - 1;
+
+                if (match === '[]') {
+                    if (!Array.isArray(current)) {
+                        current = [];
+                    }
+
+                    if (isLast) {
+                        if (!!value) {
+                            current.push(this.parseValue(value));
+                        }
+                    } else {
+                        const nextMatch = matches[i + 1];
+                        const nextIndex = parseInt(nextMatch, 10);
+
+                        if (!isNaN(nextIndex)) {
+                            if (current[nextIndex] === undefined) {
+                                current[nextIndex] = {};
+                            }
+                            current = current[nextIndex];
+                            i++; 
+                        } else {
+                            const newObj = {};
+                            current.push(newObj);
+                            current = newObj;
+                        }
+                    }
+                } else {
+                    if (isLast) {
+                        if (value !== undefined) {
+                            current[match] = this.parseValue(value);
+                        }
+                    } else {
+                        if (current[match] === undefined || typeof current[match] !== 'object') {
+                            const nextMatch = matches[i + 1];
+                            current[match] = nextMatch === '[]' ? [] : {};
+                        }
+                        current = current[match];
+                    }
+                }
+            }
+        }
+
+        private transformArrays(obj: any): any {
+            if (Array.isArray(obj)) {
+                return obj.map(item =>
+                    typeof item === 'object' && item !== null
+                        ? this.transformArrays(item)
+                        : item
+                );
+            }
+
+            if (typeof obj !== 'object' || obj === null) {
+                return obj;
+            }
+
+            const result: any = {};
+            const keys = Object.keys(obj);
+
+            const isArrayLike = keys.every(key => {
+                const num = parseInt(key, 10);
+                return !isNaN(num) && num >= 0 && num.toString() === key;
+            });
+
+            if (isArrayLike && keys.length > 0) {
+                const array: any[] = [];
+                keys.forEach(key => {
+                    const index = parseInt(key, 10);
+                    array[index] = this.transformArrays(obj[key]);
+                });
+                return array;
+            }
+
+            keys.forEach(key => {
+                const value = obj[key];
+                result[key] =
+                    typeof value === 'object' && value !== null
+                        ? this.transformArrays(value)
+                        : value;
+            });
+
+            return result;
+        }
+
+        private parseValue(value: string): Primitive {
+            if (value === 'true') return true;
+            if (value === 'false') return false;
+            if (value === 'null') return null;
+            if (value === 'undefined') return undefined;
+
+            const num = Number(value);
+            if (!isNaN(num) && value.trim() !== '') return num;
+
+            return value;
+        }
+
+        private isPrimitive(value: any): boolean {
+            return value === null ||
+                typeof value !== 'object' &&
+                typeof value !== 'function';
+        }
+
+        setOptions(newOptions: Partial<QustOptions>): void {
+            this.options = { ...this.options, ...newOptions };
+        }
+
+        getOptions(): Required<QustOptions> {
+            return { ...this.options };
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).Qust = Qust;
+            }
+        }
+    }
+
+    const qust = {
+
+        stringify(obj: QueryObject, options?: QustOptions): string {
+            return new Qust(options).stringify(obj);
+        },
+
+        parse<T = QueryObject>(queryString: string, options?: QustOptions): T {
+            return new Qust(options).parse<T>(queryString);
+        }
+    };
+
+    if (typeof window !== "undefined") {
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: qust,
+        Qust: Qust,
+        qust: qust,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = qust;
+        (global as any).Qust = Qust;
+        (global as any).qust = qust;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = qust;
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = qust;
+        exports.Qust = Qust;
+        exports.qust = qust;
+    }
+	return globalFunctModule;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type QustElementTypeGF = typeof globalFunct.Qust;
+
+type qustElementTypeGF = typeof globalFunct.qust;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const QustElementGF: QustElementTypeGF = globalFunct.Qust;
+
+const qustElementGF: qustElementTypeGF = globalFunct.qust;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+
+

package/ts/index.ts

@@ -0,0 +1,436 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Qust: any;
+    qust: any;
+    __bundledModules: any;
+}
+
+interface QustOptions {
+    arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'none';
+    arraySeparator?: string;
+    skipNull?: boolean;
+    skipEmptyString?: boolean;
+    encode?: boolean;
+    decode?: boolean;
+    depth?: number;
+}
+
+
+type Primitive = string | number | boolean | null | undefined;
+
+type QueryValue = Primitive | Primitive[] | { [key: string]: QueryValue };
+
+type QueryObject = { [key: string]: QueryValue };
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+
+
+
+
+
+
+
+    const DEFAULT_OPTIONS: Required<QustOptions> = {
+        arrayFormat: 'bracket',
+        arraySeparator: ',',
+        skipNull: true,
+        skipEmptyString: false,
+        encode: true,
+        decode: true,
+        depth: 10
+    };
+
+    class Qust {
+        private options: Required<QustOptions>;
+
+        constructor(options: QustOptions = {}) {
+            this.options = { ...DEFAULT_OPTIONS, ...options };
+        }
+
+        stringify(obj: QueryObject): string {
+            if (!obj || typeof obj !== 'object') {
+                return '';
+            }
+
+            const parts: string[] = [];
+            this.processObject('', obj, parts, 0);
+
+            return parts.length > 0 ? `?${parts.join('&')}` : '';
+        }
+
+        parse<T = QueryObject>(queryString: string): T {
+            if (!queryString || typeof queryString !== 'string') {
+                return {} as T;
+            }
+
+            const cleanString = queryString.startsWith('?')
+                ? queryString.slice(1)
+                : queryString;
+
+            if (!cleanString) {
+                return {} as T;
+            }
+
+            const result: QueryObject = {};
+            const pairs = cleanString.split('&');
+
+            for (const pair of pairs) {
+                if (!pair) continue;
+
+                const [encodedKey, encodedValue] = pair.split('=');
+
+                if (!encodedKey) continue;
+
+                const key = this.options.decode
+                    ? decodeURIComponent(encodedKey)
+                    : encodedKey;
+
+                const value = this.options.decode && encodedValue !== undefined
+                    ? decodeURIComponent(encodedValue)
+                    : encodedValue;
+
+                this.setValue(result, key, value);
+            }
+
+            return this.transformArrays(result) as T;
+        }
+
+        private processObject(
+            prefix: string,
+            value: QueryValue,
+            parts: string[],
+            depth: number
+        ): void {
+            if (depth > this.options.depth) {
+                console.warn('Qust: Profondeur maximale atteinte, arrêt de la récursion');
+                return;
+            }
+
+            if (value === null || value === undefined) {
+                if (!this.options.skipNull) {
+                    parts.push(this.encodeKey(prefix));
+                }
+                return;
+            }
+
+            if (typeof value === 'string' && value === '' && this.options.skipEmptyString) {
+                return;
+            }
+
+            if (Array.isArray(value)) {
+                this.processArray(prefix, value, parts, depth + 1);
+                return;
+            }
+
+            if (typeof value === 'object' && !this.isPrimitive(value)) {
+                for (const [key, val] of Object.entries(value)) {
+                    const newPrefix = prefix ? `${prefix}[${key}]` : key;
+                    this.processObject(newPrefix, val, parts, depth + 1);
+                }
+                return;
+            }
+
+            const encodedKey = this.encodeKey(prefix);
+            const encodedValue = this.options.encode && typeof value === 'string'
+                ? encodeURIComponent(value)
+                : String(value);
+
+            parts.push(`${encodedKey}=${encodedValue}`);
+        }
+
+        private processArray(
+            prefix: string,
+            array: Primitive[],
+            parts: string[],
+            depth: number
+        ): void {
+            if (array.length === 0) return;
+
+            const encodedKey = this.encodeKey(prefix);
+
+            switch (this.options.arrayFormat) {
+                case 'comma':
+                    const values = array
+                        .map(item => this.options.encode && typeof item === 'string'
+                            ? encodeURIComponent(item)
+                            : String(item)
+                        )
+                        .join(this.options.arraySeparator);
+                    parts.push(`${encodedKey}=${values}`);
+                    break;
+
+                case 'index':
+                    array.forEach((item, index) => {
+                        const arrayPrefix = `${prefix}[${index}]`;
+                        this.processObject(arrayPrefix, item, parts, depth);
+                    });
+                    break;
+
+                case 'separator':
+                    array.forEach(item => {
+                        const encodedValue = this.options.encode && typeof item === 'string'
+                            ? encodeURIComponent(item)
+                            : String(item);
+                        parts.push(`${encodedKey}=${encodedValue}`);
+                    });
+                    break;
+
+                case 'none':
+                    array.forEach(item => {
+                        this.processObject(prefix, item, parts, depth);
+                    });
+                    break;
+
+                case 'bracket':
+                default:
+                    array.forEach(item => {
+                        const arrayPrefix = `${prefix}[]`;
+                        this.processObject(arrayPrefix, item, parts, depth);
+                    });
+                    break;
+            }
+        }
+
+        private encodeKey(key: string): string {
+            if (!this.options.encode) {
+                return key;
+            }
+
+            const parts: string[] = [];
+            let currentPart = '';
+
+            for (let i = 0; i < key.length; i++) {
+                const char = key[i];
+
+                if (char === '[' || char === ']') {
+
+                    if (currentPart) {
+                        parts.push(encodeURIComponent(currentPart));
+                        currentPart = '';
+                    }
+
+                    parts.push(char);
+                } else {
+                    currentPart += char;
+                }
+            }
+
+            if (currentPart) {
+                parts.push(encodeURIComponent(currentPart));
+            }
+
+            return parts.join('');
+        }
+
+        private setValue(obj: QueryObject, key: string, value: string | undefined): void {
+            const matches = key.match(/([^\[\]]+)|(\[\])/g);
+
+            if (!matches) {
+                if (value !== undefined) {
+                    obj[key] = this.parseValue(value);
+                }
+                return;
+            }
+
+            let current: any = obj;
+
+            for (let i = 0; i < matches.length; i++) {
+                const match = matches[i];
+                const isLast = i === matches.length - 1;
+
+                if (match === '[]') {
+                    if (!Array.isArray(current)) {
+                        current = [];
+                    }
+
+                    if (isLast) {
+                        if (!!value) {
+                            current.push(this.parseValue(value));
+                        }
+                    } else {
+                        const nextMatch = matches[i + 1];
+                        const nextIndex = parseInt(nextMatch, 10);
+
+                        if (!isNaN(nextIndex)) {
+                            if (current[nextIndex] === undefined) {
+                                current[nextIndex] = {};
+                            }
+                            current = current[nextIndex];
+                            i++; 
+                        } else {
+                            const newObj = {};
+                            current.push(newObj);
+                            current = newObj;
+                        }
+                    }
+                } else {
+                    if (isLast) {
+                        if (value !== undefined) {
+                            current[match] = this.parseValue(value);
+                        }
+                    } else {
+                        if (current[match] === undefined || typeof current[match] !== 'object') {
+                            const nextMatch = matches[i + 1];
+                            current[match] = nextMatch === '[]' ? [] : {};
+                        }
+                        current = current[match];
+                    }
+                }
+            }
+        }
+
+        private transformArrays(obj: any): any {
+            if (Array.isArray(obj)) {
+                return obj.map(item =>
+                    typeof item === 'object' && item !== null
+                        ? this.transformArrays(item)
+                        : item
+                );
+            }
+
+            if (typeof obj !== 'object' || obj === null) {
+                return obj;
+            }
+
+            const result: any = {};
+            const keys = Object.keys(obj);
+
+            const isArrayLike = keys.every(key => {
+                const num = parseInt(key, 10);
+                return !isNaN(num) && num >= 0 && num.toString() === key;
+            });
+
+            if (isArrayLike && keys.length > 0) {
+                const array: any[] = [];
+                keys.forEach(key => {
+                    const index = parseInt(key, 10);
+                    array[index] = this.transformArrays(obj[key]);
+                });
+                return array;
+            }
+
+            keys.forEach(key => {
+                const value = obj[key];
+                result[key] =
+                    typeof value === 'object' && value !== null
+                        ? this.transformArrays(value)
+                        : value;
+            });
+
+            return result;
+        }
+
+        private parseValue(value: string): Primitive {
+            if (value === 'true') return true;
+            if (value === 'false') return false;
+            if (value === 'null') return null;
+            if (value === 'undefined') return undefined;
+
+            const num = Number(value);
+            if (!isNaN(num) && value.trim() !== '') return num;
+
+            return value;
+        }
+
+        private isPrimitive(value: any): boolean {
+            return value === null ||
+                typeof value !== 'object' &&
+                typeof value !== 'function';
+        }
+
+        setOptions(newOptions: Partial<QustOptions>): void {
+            this.options = { ...this.options, ...newOptions };
+        }
+
+        getOptions(): Required<QustOptions> {
+            return { ...this.options };
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).Qust = Qust;
+            }
+        }
+    }
+
+    const qust = {
+
+        stringify(obj: QueryObject, options?: QustOptions): string {
+            return new Qust(options).stringify(obj);
+        },
+
+        parse<T = QueryObject>(queryString: string, options?: QustOptions): T {
+            return new Qust(options).parse<T>(queryString);
+        }
+    };
+
+    if (typeof window !== "undefined") {
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: qust,
+        Qust: Qust,
+        qust: qust,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = qust;
+        (global as any).Qust = Qust;
+        (global as any).qust = qust;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = qust;
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = qust;
+        exports.Qust = Qust;
+        exports.qust = qust;
+    }
+	return globalFunctModule;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type QustElementTypeGF = typeof globalFunct.Qust;
+
+type qustElementTypeGF = typeof globalFunct.qust;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const QustElementGF: QustElementTypeGF = globalFunct.Qust;
+
+const qustElementGF: qustElementTypeGF = globalFunct.qust;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+export {
+	defaultElementGF as default,
+	QustElementGF as Qust,
+	qustElementGF as qust,
+};
+export type {
+	DefaultElementTypeGF,
+	QustElementTypeGF,qustElementTypeGF,
+};

package/ts/qust.ts

@@ -0,0 +1,429 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Qust: any;
+    qust: any;
+    __bundledModules: any;
+}
+
+interface QustOptions {
+    arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'none';
+    arraySeparator?: string;
+    skipNull?: boolean;
+    skipEmptyString?: boolean;
+    encode?: boolean;
+    decode?: boolean;
+    depth?: number;
+}
+
+
+type Primitive = string | number | boolean | null | undefined;
+
+type QueryValue = Primitive | Primitive[] | { [key: string]: QueryValue };
+
+type QueryObject = { [key: string]: QueryValue };
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+
+
+
+
+
+
+
+    const DEFAULT_OPTIONS: Required<QustOptions> = {
+        arrayFormat: 'bracket',
+        arraySeparator: ',',
+        skipNull: true,
+        skipEmptyString: false,
+        encode: true,
+        decode: true,
+        depth: 10
+    };
+
+    class Qust {
+        private options: Required<QustOptions>;
+
+        constructor(options: QustOptions = {}) {
+            this.options = { ...DEFAULT_OPTIONS, ...options };
+        }
+
+        stringify(obj: QueryObject): string {
+            if (!obj || typeof obj !== 'object') {
+                return '';
+            }
+
+            const parts: string[] = [];
+            this.processObject('', obj, parts, 0);
+
+            return parts.length > 0 ? `?${parts.join('&')}` : '';
+        }
+
+        parse<T = QueryObject>(queryString: string): T {
+            if (!queryString || typeof queryString !== 'string') {
+                return {} as T;
+            }
+
+            const cleanString = queryString.startsWith('?')
+                ? queryString.slice(1)
+                : queryString;
+
+            if (!cleanString) {
+                return {} as T;
+            }
+
+            const result: QueryObject = {};
+            const pairs = cleanString.split('&');
+
+            for (const pair of pairs) {
+                if (!pair) continue;
+
+                const [encodedKey, encodedValue] = pair.split('=');
+
+                if (!encodedKey) continue;
+
+                const key = this.options.decode
+                    ? decodeURIComponent(encodedKey)
+                    : encodedKey;
+
+                const value = this.options.decode && encodedValue !== undefined
+                    ? decodeURIComponent(encodedValue)
+                    : encodedValue;
+
+                this.setValue(result, key, value);
+            }
+
+            return this.transformArrays(result) as T;
+        }
+
+        private processObject(
+            prefix: string,
+            value: QueryValue,
+            parts: string[],
+            depth: number
+        ): void {
+            if (depth > this.options.depth) {
+                console.warn('Qust: Profondeur maximale atteinte, arrêt de la récursion');
+                return;
+            }
+
+            if (value === null || value === undefined) {
+                if (!this.options.skipNull) {
+                    parts.push(this.encodeKey(prefix));
+                }
+                return;
+            }
+
+            if (typeof value === 'string' && value === '' && this.options.skipEmptyString) {
+                return;
+            }
+
+            if (Array.isArray(value)) {
+                this.processArray(prefix, value, parts, depth + 1);
+                return;
+            }
+
+            if (typeof value === 'object' && !this.isPrimitive(value)) {
+                for (const [key, val] of Object.entries(value)) {
+                    const newPrefix = prefix ? `${prefix}[${key}]` : key;
+                    this.processObject(newPrefix, val, parts, depth + 1);
+                }
+                return;
+            }
+
+            const encodedKey = this.encodeKey(prefix);
+            const encodedValue = this.options.encode && typeof value === 'string'
+                ? encodeURIComponent(value)
+                : String(value);
+
+            parts.push(`${encodedKey}=${encodedValue}`);
+        }
+
+        private processArray(
+            prefix: string,
+            array: Primitive[],
+            parts: string[],
+            depth: number
+        ): void {
+            if (array.length === 0) return;
+
+            const encodedKey = this.encodeKey(prefix);
+
+            switch (this.options.arrayFormat) {
+                case 'comma':
+                    const values = array
+                        .map(item => this.options.encode && typeof item === 'string'
+                            ? encodeURIComponent(item)
+                            : String(item)
+                        )
+                        .join(this.options.arraySeparator);
+                    parts.push(`${encodedKey}=${values}`);
+                    break;
+
+                case 'index':
+                    array.forEach((item, index) => {
+                        const arrayPrefix = `${prefix}[${index}]`;
+                        this.processObject(arrayPrefix, item, parts, depth);
+                    });
+                    break;
+
+                case 'separator':
+                    array.forEach(item => {
+                        const encodedValue = this.options.encode && typeof item === 'string'
+                            ? encodeURIComponent(item)
+                            : String(item);
+                        parts.push(`${encodedKey}=${encodedValue}`);
+                    });
+                    break;
+
+                case 'none':
+                    array.forEach(item => {
+                        this.processObject(prefix, item, parts, depth);
+                    });
+                    break;
+
+                case 'bracket':
+                default:
+                    array.forEach(item => {
+                        const arrayPrefix = `${prefix}[]`;
+                        this.processObject(arrayPrefix, item, parts, depth);
+                    });
+                    break;
+            }
+        }
+
+        private encodeKey(key: string): string {
+            if (!this.options.encode) {
+                return key;
+            }
+
+            const parts: string[] = [];
+            let currentPart = '';
+
+            for (let i = 0; i < key.length; i++) {
+                const char = key[i];
+
+                if (char === '[' || char === ']') {
+
+                    if (currentPart) {
+                        parts.push(encodeURIComponent(currentPart));
+                        currentPart = '';
+                    }
+
+                    parts.push(char);
+                } else {
+                    currentPart += char;
+                }
+            }
+
+            if (currentPart) {
+                parts.push(encodeURIComponent(currentPart));
+            }
+
+            return parts.join('');
+        }
+
+        private setValue(obj: QueryObject, key: string, value: string | undefined): void {
+            const matches = key.match(/([^\[\]]+)|(\[\])/g);
+
+            if (!matches) {
+                if (value !== undefined) {
+                    obj[key] = this.parseValue(value);
+                }
+                return;
+            }
+
+            let current: any = obj;
+
+            for (let i = 0; i < matches.length; i++) {
+                const match = matches[i];
+                const isLast = i === matches.length - 1;
+
+                if (match === '[]') {
+                    if (!Array.isArray(current)) {
+                        current = [];
+                    }
+
+                    if (isLast) {
+                        if (!!value) {
+                            current.push(this.parseValue(value));
+                        }
+                    } else {
+                        const nextMatch = matches[i + 1];
+                        const nextIndex = parseInt(nextMatch, 10);
+
+                        if (!isNaN(nextIndex)) {
+                            if (current[nextIndex] === undefined) {
+                                current[nextIndex] = {};
+                            }
+                            current = current[nextIndex];
+                            i++; 
+                        } else {
+                            const newObj = {};
+                            current.push(newObj);
+                            current = newObj;
+                        }
+                    }
+                } else {
+                    if (isLast) {
+                        if (value !== undefined) {
+                            current[match] = this.parseValue(value);
+                        }
+                    } else {
+                        if (current[match] === undefined || typeof current[match] !== 'object') {
+                            const nextMatch = matches[i + 1];
+                            current[match] = nextMatch === '[]' ? [] : {};
+                        }
+                        current = current[match];
+                    }
+                }
+            }
+        }
+
+        private transformArrays(obj: any): any {
+            if (Array.isArray(obj)) {
+                return obj.map(item =>
+                    typeof item === 'object' && item !== null
+                        ? this.transformArrays(item)
+                        : item
+                );
+            }
+
+            if (typeof obj !== 'object' || obj === null) {
+                return obj;
+            }
+
+            const result: any = {};
+            const keys = Object.keys(obj);
+
+            const isArrayLike = keys.every(key => {
+                const num = parseInt(key, 10);
+                return !isNaN(num) && num >= 0 && num.toString() === key;
+            });
+
+            if (isArrayLike && keys.length > 0) {
+                const array: any[] = [];
+                keys.forEach(key => {
+                    const index = parseInt(key, 10);
+                    array[index] = this.transformArrays(obj[key]);
+                });
+                return array;
+            }
+
+            keys.forEach(key => {
+                const value = obj[key];
+                result[key] =
+                    typeof value === 'object' && value !== null
+                        ? this.transformArrays(value)
+                        : value;
+            });
+
+            return result;
+        }
+
+        private parseValue(value: string): Primitive {
+            if (value === 'true') return true;
+            if (value === 'false') return false;
+            if (value === 'null') return null;
+            if (value === 'undefined') return undefined;
+
+            const num = Number(value);
+            if (!isNaN(num) && value.trim() !== '') return num;
+
+            return value;
+        }
+
+        private isPrimitive(value: any): boolean {
+            return value === null ||
+                typeof value !== 'object' &&
+                typeof value !== 'function';
+        }
+
+        setOptions(newOptions: Partial<QustOptions>): void {
+            this.options = { ...this.options, ...newOptions };
+        }
+
+        getOptions(): Required<QustOptions> {
+            return { ...this.options };
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).Qust = Qust;
+            }
+        }
+    }
+
+    const qust = {
+
+        stringify(obj: QueryObject, options?: QustOptions): string {
+            return new Qust(options).stringify(obj);
+        },
+
+        parse<T = QueryObject>(queryString: string, options?: QustOptions): T {
+            return new Qust(options).parse<T>(queryString);
+        }
+    };
+
+    if (typeof window !== "undefined") {
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: qust,
+        Qust: Qust,
+        qust: qust,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = qust;
+        (global as any).Qust = Qust;
+        (global as any).qust = qust;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = qust;
+        (window as any).Qust = Qust;
+        (window as any).qust = qust;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = qust;
+        exports.Qust = Qust;
+        exports.qust = qust;
+    }
+	return globalFunctModule;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type QustElementTypeGF = typeof globalFunct.Qust;
+
+type qustElementTypeGF = typeof globalFunct.qust;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const QustElementGF: QustElementTypeGF = globalFunct.Qust;
+
+const qustElementGF: qustElementTypeGF = globalFunct.qust;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+
+