ee-core 4.1.5 → 5.0.0-beta.5

package/dist/cjs/utils/json.d.ts

@@ -0,0 +1,64 @@
+/** JSON write options */
+export interface JsonWriteOptions {
+    /** Number of indent spaces, default 2 */
+    space?: number;
+    /** JSON.stringify replacer function for custom serialization logic */
+    replacer?: (key: string, value: unknown) => unknown;
+}
+/**
+ * Strictly parse a JSON string
+ *
+ * Unlike JSON.parse, additionally validates that the parsed result must be an object type,
+ * preventing primitive type values (such as strings, numbers) from being parsed.
+ *
+ * @param str - JSON string
+ * @returns Parsed object
+ * @throws Error - Throws when parse result is not an object
+ */
+export declare function strictParse(str: string): unknown;
+/**
+ * Synchronously read a JSON file
+ *
+ * Reads file content and parses it as an object; throws if file does not exist.
+ *
+ * @param filepath - JSON file path
+ * @returns Parsed object
+ * @throws Error - Throws when file does not exist
+ */
+export declare function readSync(filepath: string): unknown;
+/**
+ * Synchronously write a JSON file
+ *
+ * Automatically creates the target directory, objects are automatically serialized to JSON string,
+ * non-object values are converted to string for writing. Default uses 2-space indentation.
+ *
+ * @param filepath - Target file path
+ * @param str - Content to write, objects will be serialized by JSON.stringify
+ * @param options - Write options (indentation, replacer)
+ */
+export declare function writeSync(filepath: string, str: unknown, options?: JsonWriteOptions): void;
+/**
+ * Asynchronously read a JSON file
+ *
+ * First checks if the file exists and is a regular file, then reads and parses it.
+ * Uses fs.promises async API, does not block the event loop.
+ *
+ * @param filepath - JSON file path
+ * @returns Promise of the parsed object
+ * @throws Error - Throws when file does not exist or is not a file
+ */
+export declare function read(filepath: string): Promise<unknown>;
+/**
+ * Asynchronously write a JSON file
+ *
+ * Automatically creates the target directory, objects are automatically serialized to JSON string,
+ * non-object values are converted to string for writing. Default uses 2-space indentation.
+ * Uses fs.promises async API, does not block the event loop.
+ *
+ * @param filepath - Target file path
+ * @param str - Content to write, objects will be serialized by JSON.stringify
+ * @param options - Write options (indentation, replacer)
+ * @returns Promise that resolves when writing is complete
+ */
+export declare function write(filepath: string, str: unknown, options?: JsonWriteOptions): Promise<void>;
+//# sourceMappingURL=json.d.ts.map

package/dist/cjs/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/utils/json.ts"],"names":[],"mappings":"AASA,yBAAyB;AACzB,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAKlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,gBAAqB,GAAG,IAAI,CAc9F;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAWvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYnG"}

package/dist/cjs/utils/json.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strictParse = strictParse;
+exports.readSync = readSync;
+exports.writeSync = writeSync;
+exports.read = read;
+exports.write = write;
+/**
+ * @module utils/json
+ * @description JSON file read/write utility. Provides synchronous and asynchronous JSON file
+ * read/write functions, automatically handling directory creation, object serialization, and
+ * file path checking, simplifying JSON file operations in framework and business code.
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Strictly parse a JSON string
+ *
+ * Unlike JSON.parse, additionally validates that the parsed result must be an object type,
+ * preventing primitive type values (such as strings, numbers) from being parsed.
+ *
+ * @param str - JSON string
+ * @returns Parsed object
+ * @throws Error - Throws when parse result is not an object
+ */
+function strictParse(str) {
+    const obj = JSON.parse(str);
+    // Ensure parse result is an object, excluding null, primitive values, and arrays
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('JSON string is not object');
+    }
+    return obj;
+}
+/**
+ * Synchronously read a JSON file
+ *
+ * Reads file content and parses it as an object; throws if file does not exist.
+ *
+ * @param filepath - JSON file path
+ * @returns Parsed object
+ * @throws Error - Throws when file does not exist
+ */
+function readSync(filepath) {
+    if (!fs_1.default.existsSync(filepath)) {
+        throw new Error(filepath + ' is not found');
+    }
+    return JSON.parse(fs_1.default.readFileSync(filepath, 'utf8'));
+}
+/**
+ * Synchronously write a JSON file
+ *
+ * Automatically creates the target directory, objects are automatically serialized to JSON string,
+ * non-object values are converted to string for writing. Default uses 2-space indentation.
+ *
+ * @param filepath - Target file path
+ * @param str - Content to write, objects will be serialized by JSON.stringify
+ * @param options - Write options (indentation, replacer)
+ */
+function writeSync(filepath, str, options = {}) {
+    const opts = { space: 2, ...options };
+    // Ensure target directory exists, avoiding write errors due to missing directory
+    fs_1.default.mkdirSync(path_1.default.dirname(filepath), { recursive: true });
+    let content;
+    if (typeof str === 'object') {
+        content = JSON.stringify(str, opts.replacer, opts.space) + '\n';
+    }
+    else {
+        // Non-object values are converted to string directly for writing
+        content = String(str);
+    }
+    fs_1.default.writeFileSync(filepath, content);
+}
+/**
+ * Asynchronously read a JSON file
+ *
+ * First checks if the file exists and is a regular file, then reads and parses it.
+ * Uses fs.promises async API, does not block the event loop.
+ *
+ * @param filepath - JSON file path
+ * @returns Promise of the parsed object
+ * @throws Error - Throws when file does not exist or is not a file
+ */
+function read(filepath) {
+    return fs_1.default.promises
+        .stat(filepath)
+        .then((stats) => {
+        // Ensure path points to a regular file, not a directory
+        if (!stats.isFile()) {
+            throw new Error(filepath + ' is not found');
+        }
+        return fs_1.default.promises.readFile(filepath, 'utf8');
+    })
+        .then((buf) => JSON.parse(buf));
+}
+/**
+ * Asynchronously write a JSON file
+ *
+ * Automatically creates the target directory, objects are automatically serialized to JSON string,
+ * non-object values are converted to string for writing. Default uses 2-space indentation.
+ * Uses fs.promises async API, does not block the event loop.
+ *
+ * @param filepath - Target file path
+ * @param str - Content to write, objects will be serialized by JSON.stringify
+ * @param options - Write options (indentation, replacer)
+ * @returns Promise that resolves when writing is complete
+ */
+function write(filepath, str, options = {}) {
+    const opts = { space: 2, ...options };
+    let content;
+    if (typeof str === 'object') {
+        content = JSON.stringify(str, opts.replacer, opts.space) + '\n';
+    }
+    else {
+        content = String(str);
+    }
+    // First ensure directory exists, then write the file
+    return fs_1.default.promises.mkdir(path_1.default.dirname(filepath), { recursive: true }).then(() => fs_1.default.promises.writeFile(filepath, content));
+}
+//# sourceMappingURL=json.js.map

package/dist/cjs/utils/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../src/utils/json.ts"],"names":[],"mappings":";;;;;AA2BA,kCAOC;AAWD,4BAKC;AAYD,8BAcC;AAYD,oBAWC;AAcD,sBAYC;AA7HD;;;;;GAKG;AACH,4CAAoB;AACpB,gDAAwB;AAUxB;;;;;;;;;GASG;AACH,SAAgB,WAAW,CAAC,GAAW;IACrC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5B,iFAAiF;IACjF,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,QAAQ,CAAC,QAAgB;IACvC,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,QAAQ,GAAG,eAAe,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,SAAS,CAAC,QAAgB,EAAE,GAAY,EAAE,UAA4B,EAAE;IACtF,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC;IAEtC,iFAAiF;IACjF,YAAE,CAAC,SAAS,CAAC,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,IAAI,OAAe,CAAC;IACpB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,QAAoD,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAC9G,CAAC;SAAM,CAAC;QACN,iEAAiE;QACjE,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IAED,YAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,IAAI,CAAC,QAAgB;IACnC,OAAO,YAAE,CAAC,QAAQ;SACf,IAAI,CAAC,QAAQ,CAAC;SACd,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QACd,wDAAwD;QACxD,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,QAAQ,GAAG,eAAe,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,YAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAChD,CAAC,CAAC;SACD,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,KAAK,CAAC,QAAgB,EAAE,GAAY,EAAE,UAA4B,EAAE;IAClF,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC;IAEtC,IAAI,OAAe,CAAC;IACpB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,QAAoD,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAC9G,CAAC;SAAM,CAAC;QACN,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IAED,qDAAqD;IACrD,OAAO,YAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,YAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAC7H,CAAC"}

package/dist/cjs/utils/pargv.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @module utils/pargv
+ * @description Lightweight command line argument parser. Provides parseArgv() function that
+ * parses a string array into a structured key-value object, supporting short options,
+ * long options, aliases, boolean flags, nested properties, and more.
+ *
+ * Parsing steps:
+ * 1. Initialization phase: process boolean/string/alias/default configuration, build flag mappings
+ * 2. Split phase: separate arguments into options and non-options parts using '--' as delimiter
+ * 3. Item-by-item parsing phase:
+ *    - `--key=value`: long option with equals sign assignment
+ *    - `--no-key`: long option negation form (boolean false)
+ *    - `--key value`: long option followed by value
+ *    - `-abc`: short option combination (each letter is a separate option)
+ *    - Bare values: stored in argv._ array
+ * 4. Default value filling: fill default values for keys that did not appear
+ * 5. Non-option argument handling: based on '--' option, store in argv['--'] or argv._
+ *
+ * Security: automatically skips __proto__ and constructor properties, preventing prototype chain pollution.
+ */
+/** Command line parsing options */
+export interface ParseArgvOptions {
+    /** Declare boolean-type parameters. When true, all --flags are treated as boolean; or specify a list of parameter names */
+    boolean?: boolean | string[];
+    /** Parameter alias mapping, e.g. { h: 'help', v: 'version' } */
+    alias?: Record<string, string | string[]>;
+    /** Declare string-type parameters; these parameters will not be auto-converted to numbers */
+    string?: string | string[];
+    /** Parameter default value mapping */
+    default?: Record<string, unknown>;
+    /** Unknown argument handler function; returning false prevents the argument from being parsed */
+    unknown?: (arg: string) => boolean | void;
+    /** Stop parsing when the first non-option argument is encountered; remaining arguments go into _ array */
+    stopEarly?: boolean;
+    /** Whether to put arguments after '--' into argv['--'] array instead of argv._ */
+    '--'?: boolean;
+}
+/** Parsed result object */
+export interface ParsedArgv {
+    /** Non-option argument list (bare values and positional arguments) */
+    _: (string | number)[];
+    /** Argument list after '--' separator (only present when opts['--'] is true) */
+    '--'?: string[];
+    /** Parsed key-value pairs; key names support dot notation nesting (e.g. 'a.b' -> { a: { b: ... } }) */
+    [key: string]: unknown;
+}
+/**
+ * Parse command line argument array
+ *
+ * Parses a process.argv-style string array into a structured key-value object.
+ *
+ * @param args - Argument array (typically process.argv.slice(2))
+ * @param opts - Parsing options
+ * @returns Parsed result object
+ *
+ * @example
+ * ```ts
+ * parseArgv(['--name=foo', '-p', '8080', '--verbose', 'file.txt'], {
+ *   boolean: ['verbose'],
+ *   alias: { p: 'port' },
+ *   string: ['name'],
+ * })
+ * // => { _: ['file.txt'], name: 'foo', port: 8080, verbose: true }
+ * ```
+ */
+export declare function parseArgv(args: string[], opts?: ParseArgvOptions): ParsedArgv;
+//# sourceMappingURL=pargv.d.ts.map

package/dist/cjs/utils/pargv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pargv.d.ts","sourceRoot":"","sources":["../../../src/utils/pargv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAiDH,mCAAmC;AACnC,MAAM,WAAW,gBAAgB;IAC/B,2HAA2H;IAC3H,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;IAC7B,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC1C,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,iGAAiG;IACjG,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;IAC1C,0GAA0G;IAC1G,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kFAAkF;IAClF,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,2BAA2B;AAC3B,MAAM,WAAW,UAAU;IACzB,sEAAsE;IACtE,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACvB,gFAAgF;IAChF,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,uGAAuG;IACvG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,UAAU,CA0U7E"}

package/dist/cjs/utils/pargv.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * @module utils/pargv
+ * @description Lightweight command line argument parser. Provides parseArgv() function that
+ * parses a string array into a structured key-value object, supporting short options,
+ * long options, aliases, boolean flags, nested properties, and more.
+ *
+ * Parsing steps:
+ * 1. Initialization phase: process boolean/string/alias/default configuration, build flag mappings
+ * 2. Split phase: separate arguments into options and non-options parts using '--' as delimiter
+ * 3. Item-by-item parsing phase:
+ *    - `--key=value`: long option with equals sign assignment
+ *    - `--no-key`: long option negation form (boolean false)
+ *    - `--key value`: long option followed by value
+ *    - `-abc`: short option combination (each letter is a separate option)
+ *    - Bare values: stored in argv._ array
+ * 4. Default value filling: fill default values for keys that did not appear
+ * 5. Non-option argument handling: based on '--' option, store in argv['--'] or argv._
+ *
+ * Security: automatically skips __proto__ and constructor properties, preventing prototype chain pollution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgv = parseArgv;
+/**
+ * Check if an object has the specified nested key path
+ *
+ * Traverses down the key path, only checking key existence at the last level (not retrieving value).
+ *
+ * @param obj - Target object
+ * @param keys - Key path array (e.g. ['a', 'b', 'c'])
+ * @returns true if the key path exists
+ */
+function hasKey(obj, keys) {
+    let o = obj;
+    // Traverse to second-to-last level, retrieving values
+    keys.slice(0, -1).forEach(function (key) {
+        o = o[key] || {};
+    });
+    const key = keys[keys.length - 1];
+    if (!key)
+        return false;
+    return key in o;
+}
+/**
+ * Determine if a string is in numeric format
+ *
+ * Supports hexadecimal (0x prefix), decimal integers and decimals, scientific notation.
+ *
+ * @param x - String to check
+ * @returns true if the string is a valid numeric format
+ */
+function isNumber(x) {
+    if (/^0x[0-9a-f]+$/i.test(x))
+        return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+/**
+ * Detect if a key name is constructor or __proto__
+ *
+ * Used to prevent prototype chain pollution attacks; these special properties should not be set.
+ *
+ * @param obj - Target object
+ * @param key - Key name
+ * @returns true if the key is a dangerous property
+ */
+function isConstructorOrProto(obj, key) {
+    return (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__';
+}
+/**
+ * Parse command line argument array
+ *
+ * Parses a process.argv-style string array into a structured key-value object.
+ *
+ * @param args - Argument array (typically process.argv.slice(2))
+ * @param opts - Parsing options
+ * @returns Parsed result object
+ *
+ * @example
+ * ```ts
+ * parseArgv(['--name=foo', '-p', '8080', '--verbose', 'file.txt'], {
+ *   boolean: ['verbose'],
+ *   alias: { p: 'port' },
+ *   string: ['name'],
+ * })
+ * // => { _: ['file.txt'], name: 'foo', port: 8080, verbose: true }
+ * ```
+ */
+function parseArgv(args, opts) {
+    if (!opts)
+        opts = {};
+    // Step 1: Build flag mapping, recording which parameters are boolean or string type
+    const flags = {
+        bools: {},
+        strings: {},
+        unknownFn: null,
+    };
+    if (typeof opts.unknown === 'function') {
+        flags.unknownFn = opts.unknown;
+    }
+    // When boolean option is true, all --flag form arguments are treated as boolean
+    if (typeof opts.boolean === 'boolean' && opts.boolean) {
+        flags.allBools = true;
+    }
+    else {
+        // Otherwise only mark specified parameter names as boolean
+        [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) {
+            flags.bools[key] = true;
+        });
+    }
+    // Step 2: Build bidirectional alias mapping
+    const aliases = {};
+    /**
+     * Check if any alias of the specified key is boolean
+     *
+     * @param key - Parameter key name
+     * @returns true if any alias of the key is boolean
+     */
+    function aliasIsBoolean(key) {
+        return aliases[key]?.some(function (x) {
+            return flags.bools[x];
+        }) ?? false;
+    }
+    // Build bidirectional alias mapping: each alias can map to all other aliases and the original key
+    const aliasOpts = opts.alias || {};
+    Object.keys(aliasOpts).forEach(function (key) {
+        const aliasValue = aliasOpts[key];
+        if (!aliasValue)
+            return;
+        const aliasList = [].concat(aliasValue);
+        aliases[key] = aliasList;
+        aliasList.forEach(function (x) {
+            // Each alias maps to the original key + other aliases (excluding itself)
+            const filtered = aliasList.filter(function (y) {
+                return x !== y;
+            });
+            aliases[x] = [key].concat(filtered);
+        });
+    });
+    // Step 3: Mark string options in the flag mapping (aliases also need to be synced)
+    const stringOpts = opts.string || [];
+    const stringList = [].concat(stringOpts).filter(Boolean);
+    stringList.forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            [].concat(aliases[key]).forEach(function (k) {
+                flags.strings[k] = true;
+            });
+        }
+    });
+    // Step 4: Extract default values, fill after parsing is complete
+    const defaults = opts.default || {};
+    // Initialize result object
+    const argv = { _: [] };
+    /**
+     * Determine if a parameter key has been defined (via flags or aliases)
+     *
+     * @param key - Parameter key name
+     * @param arg - Original argument string
+     * @returns true if the key has been declared
+     */
+    function argDefined(key, arg) {
+        return (
+        // In allBools mode, --flag form arguments are all considered defined
+        (!!flags.allBools && /^--[^=]+$/.test(arg)) ||
+            !!flags.strings[key] ||
+            !!flags.bools[key] ||
+            !!aliases[key]);
+    }
+    /**
+     * Set a value along a nested key path
+     *
+     * Supports dot-separated nested properties, e.g. 'a.b.c' -> obj.a.b.c = value.
+     * If the value already exists, repeated arguments with the same key are collected as an array.
+     *
+     * @param obj - Target object
+     * @param keys - Key path array
+     * @param value - Value to set
+     */
+    function setKey(obj, keys, value) {
+        let o = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            // Skip dangerous properties, preventing prototype chain pollution
+            if (!key || isConstructorOrProto(o, key))
+                return;
+            // Auto-create object if intermediate level doesn't exist
+            if (o[key] === undefined)
+                o[key] = {};
+            const oValue = o[key];
+            // Prevent overwriting built-in prototype objects
+            if (oValue === Object.prototype ||
+                oValue === Number.prototype ||
+                oValue === String.prototype) {
+                o[key] = {};
+            }
+            if (oValue === Array.prototype)
+                o[key] = {};
+            o = o[key];
+        }
+        const lastKey = keys[keys.length - 1];
+        // Last level also checks for dangerous properties
+        if (!lastKey || isConstructorOrProto(o, lastKey))
+            return;
+        if (o === Object.prototype || o === Number.prototype || o === String.prototype) {
+            o = {};
+        }
+        if (o === Array.prototype)
+            o = {};
+        if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') {
+            // First assignment or boolean parameter: set directly
+            o[lastKey] = value;
+        }
+        else if (Array.isArray(o[lastKey])) {
+            // Existing array: append value
+            o[lastKey].push(value);
+        }
+        else {
+            // Existing single value: convert to array
+            o[lastKey] = [o[lastKey], value];
+        }
+    }
+    /**
+     * Set parameter value and sync to all aliases
+     *
+     * @param key - Parameter key name
+     * @param val - Parameter value
+     * @param arg - Original argument string (for unknown check)
+     */
+    function setArg(key, val, arg) {
+        // Unknown argument check: if argument is undeclared and unknown function returns false, skip it
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false)
+                return;
+        }
+        // Non-string-type parameters with numeric format values are auto-converted to numbers
+        const value = !flags.strings[key] && isNumber(val) ? Number(val) : val;
+        setKey(argv, key.split('.'), value);
+        // Sync value to all aliases
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+    // Step 5: Pre-set default values for boolean parameters (false when unspecified)
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    let notFlags = [];
+    // Step 6: Split arguments before and after '--'
+    const dashIndex = args.indexOf('--');
+    if (dashIndex !== -1) {
+        // All arguments after '--' are treated as non-option arguments
+        notFlags = args.slice(dashIndex + 1);
+        args = args.slice(0, dashIndex);
+    }
+    // Step 7: Parse arguments item by item
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        let next;
+        // Case 1: --key=value long option with equals sign assignment
+        if (/^--.+?=/.test(arg)) {
+            const m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            if (!m)
+                continue;
+            const argKey = m[1];
+            if (!argKey)
+                continue;
+            let value = m[2];
+            // Boolean parameter values only recognize true/false
+            if (flags.bools[argKey]) {
+                value = value !== 'false' ? 'true' : 'false';
+            }
+            setArg(argKey, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            // Case 2: --no-key negation form, equivalent to --key=false
+            const m = arg.match(/^--no-(.+)$/);
+            if (!m)
+                continue;
+            const argKey = m[1];
+            if (!argKey)
+                continue;
+            setArg(argKey, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            // Case 3: --key [value] long option followed by optional value
+            const m = arg.match(/^--(.+)$/);
+            if (!m)
+                continue;
+            const argKey = m[1];
+            if (!argKey)
+                continue;
+            next = args[i + 1];
+            if (next !== undefined &&
+                !/^(-|--)[^-]/.test(next) &&
+                !flags.bools[argKey] &&
+                !flags.allBools &&
+                (aliases[argKey] ? !aliasIsBoolean(argKey) : true)) {
+                // Next argument is a value, not a new option
+                setArg(argKey, next, arg);
+                i += 1;
+            }
+            else if (next && /^(true|false)$/.test(next)) {
+                // Explicit boolean value
+                setArg(argKey, next === 'true', arg);
+                i += 1;
+            }
+            else {
+                // No value: string type set to empty string, boolean type set to true
+                setArg(argKey, flags.strings[argKey] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            // Case 4: -abc short option combination
+            const letters = arg.slice(1, -1).split('');
+            let broken = false;
+            for (let j = 0; j < letters.length; j++) {
+                const letter = letters[j];
+                if (!letter)
+                    continue;
+                next = arg.slice(j + 2);
+                if (next === '-') {
+                    setArg(letter, next, arg);
+                    continue;
+                }
+                // -a=value form
+                if (/[A-Za-z]/.test(letter) && next && next[0] === '=') {
+                    setArg(letter, next.slice(1), arg);
+                    broken = true;
+                    break;
+                }
+                // -a123 form (letter followed by digits)
+                if (/[A-Za-z]/.test(letter) && next && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letter, next, arg);
+                    broken = true;
+                    break;
+                }
+                const nextLetter = letters[j + 1];
+                if (nextLetter && nextLetter.match(/\W/)) {
+                    // Non-alphanumeric character treated as start of value
+                    setArg(letter, arg.slice(j + 2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    // Regular short option flag
+                    setArg(letter, flags.strings[letter] ? '' : true, arg);
+                }
+            }
+            // Handle the last character of a short option combination, which may need the next argument as value
+            const lastChar = arg.slice(-1);
+            const shortKey = lastChar;
+            if (!broken && shortKey !== '-') {
+                const nextArg = args[i + 1];
+                if (nextArg &&
+                    !/^(-|--)[^-]/.test(nextArg) &&
+                    !flags.bools[shortKey] &&
+                    (aliases[shortKey] ? !aliasIsBoolean(shortKey) : true)) {
+                    setArg(shortKey, nextArg, arg);
+                    i += 1;
+                }
+                else if (nextArg && /^(true|false)$/.test(nextArg)) {
+                    setArg(shortKey, nextArg === 'true', arg);
+                    i += 1;
+                }
+                else {
+                    setArg(shortKey, flags.strings[shortKey] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            // Case 5: bare value argument, store in _ array
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push((flags.strings._ || !isNumber(arg) ? arg : Number(arg)));
+            }
+            // In stopEarly mode, all subsequent arguments go into _ array
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    // Step 8: Fill default values (only for keys not present in parsing)
+    Object.keys(defaults).forEach(function (k) {
+        if (!hasKey(argv, k.split('.'))) {
+            setKey(argv, k.split('.'), defaults[k]);
+            (aliases[k] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[k]);
+            });
+        }
+    });
+    // Step 9: Handle non-option arguments after '--' separator
+    if (opts['--']) {
+        // Store in dedicated argv['--'] array
+        argv['--'] = notFlags.slice();
+    }
+    else {
+        // Append to _ array
+        notFlags.forEach(function (k) {
+            argv._.push(k);
+        });
+    }
+    return argv;
+}
+//# sourceMappingURL=pargv.js.map