@hyperfrontend/versioning 0.1.0

package/semver/index.cjs.js

@@ -0,0 +1,1499 @@
+'use strict';
+
+/**
+ * Creates a new SemVer object.
+ *
+ * @param options - Version components
+ * @returns A new SemVer object
+ */
+function createSemVer(options) {
+    return {
+        major: options.major,
+        minor: options.minor,
+        patch: options.patch,
+        prerelease: options.prerelease ?? [],
+        build: options.build ?? [],
+        raw: options.raw,
+    };
+}
+/**
+ * Creates a SemVer representing version 0.0.0.
+ *
+ * @returns A SemVer at version 0.0.0
+ */
+function createInitialVersion() {
+    return createSemVer({ major: 0, minor: 0, patch: 0 });
+}
+/**
+ * Creates a SemVer representing version 1.0.0.
+ *
+ * @returns A SemVer at version 1.0.0
+ */
+function createFirstRelease() {
+    return createSemVer({ major: 1, minor: 0, patch: 0 });
+}
+/**
+ * Checks if the version has prerelease identifiers.
+ *
+ * @param version - The version to check
+ * @returns True if version has prerelease identifiers
+ */
+function isPrerelease(version) {
+    return version.prerelease.length > 0;
+}
+/**
+ * Checks if the version is a stable release (>= 1.0.0 with no prerelease).
+ *
+ * @param version - The version to check
+ * @returns True if version is stable
+ */
+function isStable(version) {
+    return version.major >= 1 && version.prerelease.length === 0;
+}
+/**
+ * Returns a new version with build metadata stripped.
+ *
+ * @param version - The version to strip
+ * @returns A new SemVer without build metadata
+ */
+function stripBuild(version) {
+    return createSemVer({
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch,
+        prerelease: version.prerelease,
+        build: [],
+    });
+}
+/**
+ * Returns a new version with prerelease identifiers stripped.
+ *
+ * @param version - The version to strip
+ * @returns A new SemVer without prerelease identifiers
+ */
+function stripPrerelease(version) {
+    return createSemVer({
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch,
+        prerelease: [],
+        build: version.build,
+    });
+}
+
+/**
+ * Creates a new Comparator.
+ *
+ * @param operator - The comparison operator
+ * @param version - The version to compare against
+ * @returns A new Comparator
+ */
+function createComparator(operator, version) {
+    return { operator, version };
+}
+/**
+ * Creates a new ComparatorSet.
+ *
+ * @param comparators - Array of comparators (AND logic)
+ * @returns A new ComparatorSet
+ */
+function createComparatorSet(comparators) {
+    return { comparators };
+}
+/**
+ * Creates a new Range.
+ *
+ * @param sets - Array of comparator sets (OR logic)
+ * @param raw - Original raw string
+ * @returns A new Range
+ */
+function createRange(sets, raw) {
+    return { sets, raw };
+}
+/**
+ * Creates a range that matches any version.
+ *
+ * @returns A Range matching any version (*)
+ */
+function createAnyRange() {
+    return createRange([], '*');
+}
+/**
+ * Creates a range that matches exactly one version.
+ *
+ * @param version - The exact version to match
+ * @returns A Range matching exactly the specified version
+ */
+function createExactRange(version) {
+    return createRange([createComparatorSet([createComparator('=', version)])]);
+}
+/**
+ * Checks if a range represents a wildcard/any match.
+ *
+ * @param range - The range to check
+ * @returns True if the range matches any version
+ */
+function isWildcard(range) {
+    return range.sets.length === 0 || range.raw === '*' || range.raw === '';
+}
+
+/**
+ * Safe copies of Error built-ins via factory functions.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides factory functions that use Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
+ */
+// Capture references at module initialization time
+const _Error = globalThis.Error;
+const _Reflect = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Error using the captured Error constructor.
+ * Use this instead of `new Error()`.
+ *
+ * @param message - Optional error message.
+ * @param options - Optional error options.
+ * @returns A new Error instance.
+ */
+const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
+
+/**
+ * Maximum version string length to prevent memory exhaustion.
+ */
+const MAX_VERSION_LENGTH = 256;
+/**
+ * Parses a semantic version string.
+ *
+ * Accepts versions in the format: MAJOR.MINOR.PATCH[-prerelease][+build]
+ * Optional leading 'v' or '=' prefixes are stripped.
+ *
+ * @param input - The version string to parse
+ * @returns A ParseVersionResult with the parsed version or error
+ *
+ * @example
+ * parseVersion('1.2.3') // { success: true, version: { major: 1, minor: 2, patch: 3, ... } }
+ * parseVersion('v1.0.0-alpha.1+build.123') // { success: true, ... }
+ * parseVersion('invalid') // { success: false, error: '...' }
+ */
+function parseVersion(input) {
+    // Input validation
+    if (!input || typeof input !== 'string') {
+        return { success: false, error: 'Version string is required' };
+    }
+    if (input.length > MAX_VERSION_LENGTH) {
+        return { success: false, error: `Version string exceeds maximum length of ${MAX_VERSION_LENGTH}` };
+    }
+    // Strip leading whitespace
+    let pos = 0;
+    while (pos < input.length && isWhitespace(input.charCodeAt(pos))) {
+        pos++;
+    }
+    // Strip trailing whitespace
+    let end = input.length;
+    while (end > pos && isWhitespace(input.charCodeAt(end - 1))) {
+        end--;
+    }
+    // Strip optional leading 'v' or '='
+    if (pos < end) {
+        const code = input.charCodeAt(pos);
+        if (code === 118 || code === 86) {
+            // 'v' or 'V'
+            pos++;
+        }
+        else if (code === 61) {
+            // '='
+            pos++;
+        }
+    }
+    // Parse major version
+    const majorResult = parseNumericIdentifier(input, pos, end);
+    if (!majorResult.success) {
+        return { success: false, error: majorResult.error ?? 'Invalid major version' };
+    }
+    pos = majorResult.endPos;
+    // Expect dot
+    if (pos >= end || input.charCodeAt(pos) !== 46) {
+        // '.'
+        return { success: false, error: 'Expected "." after major version' };
+    }
+    pos++;
+    // Parse minor version
+    const minorResult = parseNumericIdentifier(input, pos, end);
+    if (!minorResult.success) {
+        return { success: false, error: minorResult.error ?? 'Invalid minor version' };
+    }
+    pos = minorResult.endPos;
+    // Expect dot
+    if (pos >= end || input.charCodeAt(pos) !== 46) {
+        // '.'
+        return { success: false, error: 'Expected "." after minor version' };
+    }
+    pos++;
+    // Parse patch version
+    const patchResult = parseNumericIdentifier(input, pos, end);
+    if (!patchResult.success) {
+        return { success: false, error: patchResult.error ?? 'Invalid patch version' };
+    }
+    pos = patchResult.endPos;
+    // Parse optional prerelease
+    const prerelease = [];
+    if (pos < end && input.charCodeAt(pos) === 45) {
+        // '-'
+        pos++;
+        const prereleaseResult = parseIdentifiers(input, pos, end, [43]); // Stop at '+'
+        if (!prereleaseResult.success) {
+            return { success: false, error: prereleaseResult.error ?? 'Invalid prerelease' };
+        }
+        prerelease.push(...prereleaseResult.identifiers);
+        pos = prereleaseResult.endPos;
+    }
+    // Parse optional build metadata
+    const build = [];
+    if (pos < end && input.charCodeAt(pos) === 43) {
+        // '+'
+        pos++;
+        const buildResult = parseIdentifiers(input, pos, end, []);
+        if (!buildResult.success) {
+            return { success: false, error: buildResult.error ?? 'Invalid build metadata' };
+        }
+        build.push(...buildResult.identifiers);
+        pos = buildResult.endPos;
+    }
+    // Check for trailing characters
+    if (pos < end) {
+        return { success: false, error: `Unexpected character at position ${pos}: "${input[pos]}"` };
+    }
+    return {
+        success: true,
+        version: createSemVer({
+            major: majorResult.value,
+            minor: minorResult.value,
+            patch: patchResult.value,
+            prerelease,
+            build,
+            raw: input,
+        }),
+    };
+}
+/**
+ * Parses a version string, throwing on invalid input.
+ *
+ * @param input - The version string to parse
+ * @returns The parsed SemVer
+ * @throws {Error} If the input is not a valid version
+ */
+function parseVersionStrict(input) {
+    const result = parseVersion(input);
+    if (!result.success || !result.version) {
+        throw createError(result.error ?? 'Invalid version');
+    }
+    return result.version;
+}
+/**
+ * Attempts to coerce a string into a valid semver.
+ * More lenient than parseVersion - accepts partial versions.
+ *
+ * @param input - The string to coerce
+ * @returns The parsed SemVer or null if coercion failed
+ *
+ * @example
+ * coerceVersion('1') // { major: 1, minor: 0, patch: 0, ... }
+ * coerceVersion('1.2') // { major: 1, minor: 2, patch: 0, ... }
+ * coerceVersion('v2.0') // { major: 2, minor: 0, patch: 0, ... }
+ */
+function coerceVersion(input) {
+    if (!input || typeof input !== 'string') {
+        return null;
+    }
+    // Try strict parse first
+    const strict = parseVersion(input);
+    if (strict.success && strict.version) {
+        return strict.version;
+    }
+    // Strip leading/trailing whitespace
+    let pos = 0;
+    while (pos < input.length && isWhitespace(input.charCodeAt(pos))) {
+        pos++;
+    }
+    let end = input.length;
+    while (end > pos && isWhitespace(input.charCodeAt(end - 1))) {
+        end--;
+    }
+    // Strip optional 'v' prefix
+    if (pos < end) {
+        const code = input.charCodeAt(pos);
+        if (code === 118 || code === 86) {
+            // 'v' or 'V'
+            pos++;
+        }
+    }
+    // Parse major
+    const majorResult = parseNumericIdentifier(input, pos, end);
+    if (!majorResult.success) {
+        return null;
+    }
+    const major = majorResult.value;
+    pos = majorResult.endPos;
+    // Parse optional minor
+    let minor = 0;
+    if (pos < end && input.charCodeAt(pos) === 46) {
+        pos++;
+        const minorResult = parseNumericIdentifier(input, pos, end);
+        if (minorResult.success) {
+            minor = minorResult.value;
+            pos = minorResult.endPos;
+        }
+    }
+    // Parse optional patch
+    let patch = 0;
+    if (pos < end && input.charCodeAt(pos) === 46) {
+        pos++;
+        const patchResult = parseNumericIdentifier(input, pos, end);
+        if (patchResult.success) {
+            patch = patchResult.value;
+            // pos = patchResult.endPos // We ignore anything after patch in coerce
+        }
+    }
+    return createSemVer({
+        major,
+        minor,
+        patch,
+        prerelease: [],
+        build: [],
+        raw: input,
+    });
+}
+/**
+ * Parses a numeric identifier (non-negative integer, no leading zeros except for "0").
+ *
+ * @param input - Input string to parse
+ * @param start - Start position in the input
+ * @param end - End position in the input
+ * @returns Numeric parsing result
+ */
+function parseNumericIdentifier(input, start, end) {
+    if (start >= end) {
+        return { success: false, value: 0, endPos: start, error: 'Expected numeric identifier' };
+    }
+    let pos = start;
+    const firstCode = input.charCodeAt(pos);
+    // Must start with a digit
+    if (!isDigit(firstCode)) {
+        return { success: false, value: 0, endPos: pos, error: 'Expected digit' };
+    }
+    // Check for leading zero (only "0" is valid, not "01", "007", etc.)
+    if (firstCode === 48 && pos + 1 < end && isDigit(input.charCodeAt(pos + 1))) {
+        return { success: false, value: 0, endPos: pos, error: 'Numeric identifier cannot have leading zeros' };
+    }
+    // Consume digits
+    let value = 0;
+    while (pos < end && isDigit(input.charCodeAt(pos))) {
+        value = value * 10 + (input.charCodeAt(pos) - 48);
+        pos++;
+        // Prevent overflow
+        if (value > Number.MAX_SAFE_INTEGER) {
+            return { success: false, value: 0, endPos: pos, error: 'Numeric identifier is too large' };
+        }
+    }
+    return { success: true, value, endPos: pos };
+}
+/**
+ * Parses dot-separated identifiers (for prerelease/build).
+ *
+ * @param input - Input string to parse
+ * @param start - Start position in the input
+ * @param end - End position in the input
+ * @param stopCodes - Character codes that signal end of identifiers
+ * @returns Identifiers parsing result
+ */
+function parseIdentifiers(input, start, end, stopCodes) {
+    const identifiers = [];
+    let pos = start;
+    while (pos < end) {
+        // Check for stop characters
+        if (stopCodes.includes(input.charCodeAt(pos))) {
+            break;
+        }
+        // Parse one identifier
+        const identStart = pos;
+        while (pos < end) {
+            const code = input.charCodeAt(pos);
+            // Stop at dot or stop characters
+            if (code === 46 || stopCodes.includes(code)) {
+                break;
+            }
+            // Must be alphanumeric or hyphen
+            if (!isAlphanumeric(code) && code !== 45) {
+                return { success: false, identifiers: [], endPos: pos, error: `Invalid character in identifier: "${input[pos]}"` };
+            }
+            pos++;
+        }
+        // Empty identifier is not allowed
+        if (pos === identStart) {
+            return { success: false, identifiers: [], endPos: pos, error: 'Empty identifier' };
+        }
+        identifiers.push(input.slice(identStart, pos));
+        // Consume dot separator
+        if (pos < end && input.charCodeAt(pos) === 46) {
+            pos++;
+            // Dot at end is invalid
+            if (pos >= end || stopCodes.includes(input.charCodeAt(pos))) {
+                return { success: false, identifiers: [], endPos: pos, error: 'Identifier expected after dot' };
+            }
+        }
+    }
+    return { success: true, identifiers, endPos: pos };
+}
+/**
+ * Checks if a character code is a digit (0-9).
+ *
+ * @param code - Character code to check
+ * @returns True if the code represents a digit
+ */
+function isDigit(code) {
+    return code >= 48 && code <= 57;
+}
+/**
+ * Checks if a character code is alphanumeric or hyphen.
+ *
+ * @param code - Character code to check
+ * @returns True if the code represents an alphanumeric character
+ */
+function isAlphanumeric(code) {
+    return ((code >= 48 && code <= 57) || // 0-9
+        (code >= 65 && code <= 90) || // A-Z
+        (code >= 97 && code <= 122) // a-z
+    );
+}
+/**
+ * Checks if a character code is whitespace.
+ *
+ * @param code - Character code to check
+ * @returns True if the code represents whitespace
+ */
+function isWhitespace(code) {
+    return code === 32 || code === 9 || code === 10 || code === 13;
+}
+
+/**
+ * Safe copies of Number built-in methods and constants.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/number
+ */
+// Capture references at module initialization time
+const _parseInt = globalThis.parseInt;
+const _isNaN = globalThis.isNaN;
+// ============================================================================
+// Parsing
+// ============================================================================
+/**
+ * (Safe copy) Parses a string and returns an integer.
+ */
+const parseInt = _parseInt;
+// ============================================================================
+// Global Type Checking (legacy, less strict)
+// ============================================================================
+/**
+ * (Safe copy) Global isNaN function (coerces to number first, less strict than Number.isNaN).
+ */
+const globalIsNaN = _isNaN;
+
+/**
+ * Maximum range string length.
+ */
+const MAX_RANGE_LENGTH = 1024;
+/**
+ * Parses a semver range string.
+ *
+ * Supports:
+ * - Exact: 1.2.3, =1.2.3
+ * - Comparators: >1.0.0, >=1.0.0, <2.0.0, <=2.0.0
+ * - Caret: ^1.2.3 (compatible with version)
+ * - Tilde: ~1.2.3 (approximately equivalent)
+ * - X-ranges: 1.x, 1.2.x, *
+ * - Hyphen ranges: 1.0.0 - 2.0.0
+ * - OR: 1.0.0 || 2.0.0
+ * - AND: >=1.0.0 <2.0.0
+ *
+ * @param input - The range string to parse
+ * @returns A ParseRangeResult with the parsed range or error
+ */
+function parseRange(input) {
+    if (!input || typeof input !== 'string') {
+        return { success: false, error: 'Range string is required' };
+    }
+    if (input.length > MAX_RANGE_LENGTH) {
+        return { success: false, error: `Range string exceeds maximum length of ${MAX_RANGE_LENGTH}` };
+    }
+    // Trim whitespace
+    const trimmed = input.trim();
+    // Handle wildcard/any
+    if (trimmed === '' || trimmed === '*' || trimmed.toLowerCase() === 'x') {
+        return { success: true, range: createRange([], input) };
+    }
+    // Split by || for OR logic
+    const orParts = splitByOr(trimmed);
+    const sets = [];
+    for (const part of orParts) {
+        const setResult = parseComparatorSet(part.trim());
+        if (!setResult.success) {
+            return { success: false, error: setResult.error };
+        }
+        if (setResult.set) {
+            sets.push(setResult.set);
+        }
+    }
+    return { success: true, range: createRange(sets, input) };
+}
+/**
+ * Parses a range string, throwing on invalid input.
+ *
+ * @param input - The range string to parse
+ * @returns The parsed Range
+ * @throws {Error} If the input is not a valid range
+ */
+function parseRangeStrict(input) {
+    const result = parseRange(input);
+    if (!result.success || !result.range) {
+        throw createError(result.error ?? 'Invalid range');
+    }
+    return result.range;
+}
+/**
+ * Splits a string by || delimiter, respecting nesting.
+ *
+ * @param input - Range string containing OR groups
+ * @returns Array of OR-separated parts
+ */
+function splitByOr(input) {
+    const parts = [];
+    let current = '';
+    let pos = 0;
+    while (pos < input.length) {
+        if (input[pos] === '|' && pos + 1 < input.length && input[pos + 1] === '|') {
+            parts.push(current);
+            current = '';
+            pos += 2;
+        }
+        else {
+            current += input[pos];
+            pos++;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Parses a single comparator set (space-separated comparators = AND logic).
+ *
+ * @param input - Comparator set string
+ * @returns Parsed set result
+ */
+function parseComparatorSet(input) {
+    if (!input || input.trim() === '') {
+        return { success: true }; // Empty set matches any
+    }
+    const trimmed = input.trim();
+    // Check for hyphen range: "1.0.0 - 2.0.0"
+    const hyphenMatch = parseHyphenRange(trimmed);
+    if (hyphenMatch.isHyphenRange) {
+        if (!hyphenMatch.success) {
+            return { success: false, error: hyphenMatch.error };
+        }
+        return { success: true, set: hyphenMatch.set };
+    }
+    // Split by whitespace for AND logic
+    const tokens = splitByWhitespace(trimmed);
+    const comparators = [];
+    for (const token of tokens) {
+        const compResult = parseSingleComparator(token);
+        if (!compResult.success) {
+            return { success: false, error: compResult.error };
+        }
+        if (compResult.comparators) {
+            comparators.push(...compResult.comparators);
+        }
+    }
+    if (comparators.length === 0) {
+        return { success: true }; // Empty matches any
+    }
+    return { success: true, set: createComparatorSet(comparators) };
+}
+/**
+ * Checks for and parses hyphen ranges like "1.0.0 - 2.0.0".
+ *
+ * @param input - Potential hyphen range string
+ * @returns Hyphen range parsing result
+ */
+function parseHyphenRange(input) {
+    // Look for " - " (space-hyphen-space)
+    let hyphenPos = -1;
+    for (let i = 0; i < input.length - 2; i++) {
+        if (input[i] === ' ' && input[i + 1] === '-' && input[i + 2] === ' ') {
+            hyphenPos = i;
+            break;
+        }
+    }
+    if (hyphenPos === -1) {
+        return { isHyphenRange: false, success: true };
+    }
+    const leftPart = input.slice(0, hyphenPos).trim();
+    const rightPart = input.slice(hyphenPos + 3).trim();
+    const leftVersion = parseSimpleVersion(leftPart);
+    if (!leftVersion) {
+        return { isHyphenRange: true, success: false, error: `Invalid left side of hyphen range: "${leftPart}"` };
+    }
+    const rightVersion = parseSimpleVersion(rightPart);
+    if (!rightVersion) {
+        return { isHyphenRange: true, success: false, error: `Invalid right side of hyphen range: "${rightPart}"` };
+    }
+    // Hyphen range: >=left <=right
+    const comparators = [createComparator('>=', leftVersion), createComparator('<=', rightVersion)];
+    return {
+        isHyphenRange: true,
+        success: true,
+        set: createComparatorSet(comparators),
+    };
+}
+/**
+ * Splits by whitespace.
+ *
+ * @param input - String to split
+ * @returns Array of whitespace-separated tokens
+ */
+function splitByWhitespace(input) {
+    const tokens = [];
+    let current = '';
+    for (const char of input) {
+        if (char === ' ' || char === '\t') {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+/**
+ * Parses a single comparator token (e.g., ">=1.0.0", "^1.2.3", "~1.0").
+ *
+ * @param token - Comparator token to parse
+ * @returns Parsed comparator result
+ */
+function parseSingleComparator(token) {
+    let pos = 0;
+    let operator = '=';
+    // Parse operator
+    if (token[pos] === '^') {
+        operator = '^';
+        pos++;
+    }
+    else if (token[pos] === '~') {
+        operator = '~';
+        pos++;
+    }
+    else if (token[pos] === '>') {
+        if (token[pos + 1] === '=') {
+            operator = '>=';
+            pos += 2;
+        }
+        else {
+            operator = '>';
+            pos++;
+        }
+    }
+    else if (token[pos] === '<') {
+        if (token[pos + 1] === '=') {
+            operator = '<=';
+            pos += 2;
+        }
+        else {
+            operator = '<';
+            pos++;
+        }
+    }
+    else if (token[pos] === '=') {
+        operator = '=';
+        pos++;
+    }
+    const versionPart = token.slice(pos);
+    // Handle wildcards: *, x, X
+    if (versionPart === '*' || versionPart.toLowerCase() === 'x') {
+        // Wildcard matches any - return empty (will be handled as match-all)
+        return { success: true, comparators: [] };
+    }
+    // Handle x-ranges: 1.x, 1.2.x
+    if (versionPart.includes('x') || versionPart.includes('X') || versionPart.includes('*')) {
+        return parseXRange(versionPart);
+    }
+    // Parse version
+    const version = parseSimpleVersion(versionPart);
+    if (!version) {
+        return { success: false, error: `Invalid version in comparator: "${versionPart}"` };
+    }
+    // For caret and tilde, expand to range
+    if (operator === '^') {
+        return expandCaretRange(version);
+    }
+    if (operator === '~') {
+        return expandTildeRange(version);
+    }
+    return { success: true, comparators: [createComparator(operator, version)] };
+}
+/**
+ * Parses x-ranges like 1.x, 1.2.x, etc.
+ *
+ * @param input - X-range string to parse
+ * @param _operator - Range operator (unused but kept for interface consistency)
+ * @returns Comparator result
+ */
+function parseXRange(input, _operator) {
+    const parts = input.split('.');
+    const nums = [];
+    for (const part of parts) {
+        const lower = part.toLowerCase();
+        if (lower === 'x' || lower === '*' || lower === '') {
+            break;
+        }
+        const num = parseInt(part, 10);
+        if (globalIsNaN(num) || num < 0) {
+            return { success: false, error: `Invalid x-range: "${input}"` };
+        }
+        nums.push(num);
+    }
+    if (nums.length === 0) {
+        // * or X alone - match any
+        return { success: true, comparators: [] };
+    }
+    if (nums.length === 1) {
+        // 1.x or 1.* -> >=1.0.0 <2.0.0
+        const lower = createSemVer({ major: nums[0], minor: 0, patch: 0 });
+        const upper = createSemVer({ major: nums[0] + 1, minor: 0, patch: 0 });
+        return { success: true, comparators: [createComparator('>=', lower), createComparator('<', upper)] };
+    }
+    // 1.2.x -> >=1.2.0 <1.3.0
+    const lower = createSemVer({ major: nums[0], minor: nums[1], patch: 0 });
+    const upper = createSemVer({ major: nums[0], minor: nums[1] + 1, patch: 0 });
+    return { success: true, comparators: [createComparator('>=', lower), createComparator('<', upper)] };
+}
+/**
+ * Expands caret range: ^1.2.3 -> >=1.2.3 <2.0.0
+ *
+ * @param version - Base version for caret range
+ * @returns Expanded comparator result
+ */
+function expandCaretRange(version) {
+    let upperMajor = version.major;
+    let upperMinor = 0;
+    let upperPatch = 0;
+    if (version.major === 0) {
+        if (version.minor === 0) {
+            // ^0.0.x -> >=0.0.x <0.0.(x+1)
+            upperPatch = version.patch + 1;
+            upperMinor = version.minor;
+        }
+        else {
+            // ^0.x.y -> >=0.x.y <0.(x+1).0
+            upperMinor = version.minor + 1;
+        }
+    }
+    else {
+        // ^x.y.z -> >=x.y.z <(x+1).0.0
+        upperMajor = version.major + 1;
+    }
+    const upper = createSemVer({ major: upperMajor, minor: upperMinor, patch: upperPatch });
+    return { success: true, comparators: [createComparator('>=', version), createComparator('<', upper)] };
+}
+/**
+ * Expands tilde range: ~1.2.3 -> >=1.2.3 <1.3.0
+ *
+ * @param version - Base version for tilde range
+ * @returns Expanded comparator result
+ */
+function expandTildeRange(version) {
+    const upper = createSemVer({
+        major: version.major,
+        minor: version.minor + 1,
+        patch: 0,
+    });
+    return { success: true, comparators: [createComparator('>=', version), createComparator('<', upper)] };
+}
+/**
+ * Parses a simple version string (no range operators).
+ * More lenient - accepts partial versions.
+ *
+ * @param input - Version string to parse
+ * @returns Parsed SemVer or null if invalid
+ */
+function parseSimpleVersion(input) {
+    if (!input)
+        return null;
+    let pos = 0;
+    // Skip leading v
+    if (input[pos] === 'v' || input[pos] === 'V') {
+        pos++;
+    }
+    const parts = input.slice(pos).split('.');
+    if (parts.length === 0)
+        return null;
+    const nums = [];
+    for (const part of parts) {
+        // Stop at prerelease or build
+        const dashIdx = part.indexOf('-');
+        const plusIdx = part.indexOf('+');
+        let numPart = part;
+        if (dashIdx !== -1) {
+            numPart = part.slice(0, dashIdx);
+        }
+        else if (plusIdx !== -1) {
+            numPart = part.slice(0, plusIdx);
+        }
+        if (numPart === '' || numPart.toLowerCase() === 'x' || numPart === '*') {
+            break;
+        }
+        const num = parseInt(numPart, 10);
+        if (globalIsNaN(num) || num < 0)
+            return null;
+        nums.push(num);
+    }
+    if (nums.length === 0)
+        return null;
+    return createSemVer({
+        major: nums[0],
+        minor: nums[1] ?? 0,
+        patch: nums[2] ?? 0,
+        prerelease: [],
+        build: [],
+        raw: input,
+    });
+}
+
+/**
+ * Safe copies of Math built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
+ */
+// Capture references at module initialization time
+const _Math = globalThis.Math;
+// ============================================================================
+// Min/Max
+// ============================================================================
+/**
+ * (Safe copy) Returns the larger of zero or more numbers.
+ */
+const max$1 = _Math.max;
+
+/**
+ * Compares two semantic versions.
+ *
+ * @param a - First version
+ * @param b - Second version
+ * @returns -1 if a < b, 0 if a == b, 1 if a > b
+ *
+ * @example
+ * compare(parseVersion('1.0.0'), parseVersion('2.0.0')) // -1
+ * compare(parseVersion('1.0.0'), parseVersion('1.0.0')) // 0
+ * compare(parseVersion('2.0.0'), parseVersion('1.0.0')) // 1
+ */
+function compare(a, b) {
+    // Compare major, minor, patch
+    if (a.major !== b.major) {
+        return a.major < b.major ? -1 : 1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor < b.minor ? -1 : 1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch < b.patch ? -1 : 1;
+    }
+    // Compare prerelease
+    // Version with prerelease has lower precedence than release
+    if (a.prerelease.length === 0 && b.prerelease.length > 0) {
+        return 1; // a is release, b is prerelease -> a > b
+    }
+    if (a.prerelease.length > 0 && b.prerelease.length === 0) {
+        return -1; // a is prerelease, b is release -> a < b
+    }
+    // Both have prerelease - compare identifiers
+    const maxLen = max$1(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aId = a.prerelease[i];
+        const bId = b.prerelease[i];
+        // Shorter prerelease array has lower precedence
+        if (aId === undefined && bId !== undefined) {
+            return -1;
+        }
+        if (aId !== undefined && bId === undefined) {
+            return 1;
+        }
+        if (aId === undefined || bId === undefined) {
+            continue;
+        }
+        // Compare identifiers
+        const cmp = compareIdentifiers(aId, bId);
+        if (cmp !== 0) {
+            return cmp;
+        }
+    }
+    return 0;
+}
+/**
+ * Checks if two versions are equal (ignoring build metadata).
+ *
+ * @param a - First version
+ * @param b - Second version
+ * @returns True if versions are equal
+ */
+function eq(a, b) {
+    return compare(a, b) === 0;
+}
+/**
+ * Checks if a < b.
+ *
+ * @param a - First version to compare
+ * @param b - Second version to compare
+ * @returns True if a is less than b
+ */
+function lt(a, b) {
+    return compare(a, b) === -1;
+}
+/**
+ * Checks if a <= b.
+ *
+ * @param a - First version to compare
+ * @param b - Second version to compare
+ * @returns True if a is less than or equal to b
+ */
+function lte(a, b) {
+    return compare(a, b) !== 1;
+}
+/**
+ * Checks if a > b.
+ *
+ * @param a - First version to compare
+ * @param b - Second version to compare
+ * @returns True if a is greater than b
+ */
+function gt(a, b) {
+    return compare(a, b) === 1;
+}
+/**
+ * Checks if a >= b.
+ *
+ * @param a - First version to compare
+ * @param b - Second version to compare
+ * @returns True if a is greater than or equal to b
+ */
+function gte(a, b) {
+    return compare(a, b) !== -1;
+}
+/**
+ * Checks if a != b.
+ *
+ * @param a - First version to compare
+ * @param b - Second version to compare
+ * @returns True if versions are not equal
+ */
+function neq(a, b) {
+    return compare(a, b) !== 0;
+}
+/**
+ * Checks if a version satisfies a comparator.
+ *
+ * @param version - Version to check
+ * @param comparator - Comparator to test against
+ * @returns True if version satisfies the comparator
+ */
+function satisfiesComparator(version, comparator) {
+    const cmp = compare(version, comparator.version);
+    switch (comparator.operator) {
+        case '=':
+            return cmp === 0;
+        case '>':
+            return cmp === 1;
+        case '>=':
+            return cmp >= 0;
+        case '<':
+            return cmp === -1;
+        case '<=':
+            return cmp <= 0;
+        case '^':
+        case '~':
+            // These should have been expanded during parsing
+            // If we encounter them here, treat as >=
+            return cmp >= 0;
+        default:
+            return false;
+    }
+}
+/**
+ * Checks if a version satisfies a range.
+ *
+ * @param version - Version to check
+ * @param range - Range to test against
+ * @returns True if version satisfies the range
+ *
+ * @example
+ * satisfies(parseVersion('1.2.3'), parseRange('^1.0.0')) // true
+ * satisfies(parseVersion('2.0.0'), parseRange('^1.0.0')) // false
+ */
+function satisfies(version, range) {
+    // Empty range matches any
+    if (range.sets.length === 0) {
+        return true;
+    }
+    // OR logic: at least one set must be satisfied
+    for (const set of range.sets) {
+        // AND logic: all comparators in set must be satisfied
+        let allSatisfied = true;
+        // Empty comparator set matches any
+        if (set.comparators.length === 0) {
+            return true;
+        }
+        for (const comp of set.comparators) {
+            if (!satisfiesComparator(version, comp)) {
+                allSatisfied = false;
+                break;
+            }
+        }
+        if (allSatisfied) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Finds the maximum version that satisfies a range.
+ *
+ * @param versions - Array of versions to check
+ * @param range - Range to test against
+ * @returns The maximum satisfying version, or null if none satisfy
+ */
+function maxSatisfying(versions, range) {
+    let max = null;
+    for (const version of versions) {
+        if (satisfies(version, range)) {
+            if (max === null || gt(version, max)) {
+                max = version;
+            }
+        }
+    }
+    return max;
+}
+/**
+ * Finds the minimum version that satisfies a range.
+ *
+ * @param versions - Array of versions to check
+ * @param range - Range to test against
+ * @returns The minimum satisfying version, or null if none satisfy
+ */
+function minSatisfying(versions, range) {
+    let min = null;
+    for (const version of versions) {
+        if (satisfies(version, range)) {
+            if (min === null || lt(version, min)) {
+                min = version;
+            }
+        }
+    }
+    return min;
+}
+// ============================================================================
+// Internal helpers
+// ============================================================================
+/**
+ * Compares two prerelease identifiers.
+ * Numeric identifiers have lower precedence than alphanumeric.
+ * Numeric identifiers are compared numerically.
+ * Alphanumeric identifiers are compared lexically.
+ *
+ * @param a - First prerelease identifier
+ * @param b - Second prerelease identifier
+ * @returns -1 if a < b, 0 if equal, 1 if a > b
+ */
+function compareIdentifiers(a, b) {
+    const aIsNumeric = isNumeric(a);
+    const bIsNumeric = isNumeric(b);
+    // Numeric identifiers have lower precedence
+    if (aIsNumeric && !bIsNumeric) {
+        return -1;
+    }
+    if (!aIsNumeric && bIsNumeric) {
+        return 1;
+    }
+    // Both numeric - compare as numbers
+    if (aIsNumeric && bIsNumeric) {
+        const aNum = parseInt(a, 10);
+        const bNum = parseInt(b, 10);
+        if (aNum < bNum)
+            return -1;
+        if (aNum > bNum)
+            return 1;
+        return 0;
+    }
+    // Both alphanumeric - compare lexically
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+/**
+ * Checks if a string consists only of digits.
+ *
+ * @param str - String to check for numeric content
+ * @returns True if string contains only digits
+ */
+function isNumeric(str) {
+    if (str.length === 0)
+        return false;
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        if (code < 48 || code > 57) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Sorts an array of versions in ascending order.
+ *
+ * @param versions - Array of versions to sort
+ * @returns A new sorted array
+ *
+ * @example
+ * sort([v2, v1, v3]) // [v1, v2, v3]
+ */
+function sort(versions) {
+    return [...versions].sort(compare);
+}
+/**
+ * Sorts an array of versions in descending order.
+ *
+ * @param versions - Array of versions to sort
+ * @returns A new sorted array
+ *
+ * @example
+ * sortDescending([v1, v3, v2]) // [v3, v2, v1]
+ */
+function sortDescending(versions) {
+    return [...versions].sort((a, b) => compare(b, a));
+}
+/**
+ * Returns the maximum version from an array.
+ *
+ * @param versions - Array of versions
+ * @returns The maximum version, or null if array is empty
+ */
+function max(versions) {
+    if (versions.length === 0)
+        return null;
+    let maxVer = versions[0];
+    for (let i = 1; i < versions.length; i++) {
+        if (compare(versions[i], maxVer) === 1) {
+            maxVer = versions[i];
+        }
+    }
+    return maxVer;
+}
+/**
+ * Returns the minimum version from an array.
+ *
+ * @param versions - Array of versions
+ * @returns The minimum version, or null if array is empty
+ */
+function min(versions) {
+    if (versions.length === 0)
+        return null;
+    let minVer = versions[0];
+    for (let i = 1; i < versions.length; i++) {
+        if (compare(versions[i], minVer) === -1) {
+            minVer = versions[i];
+        }
+    }
+    return minVer;
+}
+
+/**
+ * Increments a version based on the bump type.
+ *
+ * @param version - The version to increment
+ * @param type - The type of bump (major, minor, patch, etc.)
+ * @param prereleaseId - Optional prerelease identifier for prerelease bumps
+ * @returns A new incremented SemVer
+ *
+ * @example
+ * increment(parseVersion('1.2.3'), 'minor') // 1.3.0
+ * increment(parseVersion('1.2.3'), 'major') // 2.0.0
+ * increment(parseVersion('1.2.3'), 'prerelease', 'alpha') // 1.2.4-alpha.0
+ */
+function increment(version, type, prereleaseId) {
+    switch (type) {
+        case 'major':
+            return createSemVer({
+                major: version.major + 1,
+                minor: 0,
+                patch: 0,
+                prerelease: [],
+                build: [],
+            });
+        case 'minor':
+            return createSemVer({
+                major: version.major,
+                minor: version.minor + 1,
+                patch: 0,
+                prerelease: [],
+                build: [],
+            });
+        case 'patch':
+            // If version has prerelease, just remove it (1.2.3-alpha -> 1.2.3)
+            if (version.prerelease.length > 0) {
+                return createSemVer({
+                    major: version.major,
+                    minor: version.minor,
+                    patch: version.patch,
+                    prerelease: [],
+                    build: [],
+                });
+            }
+            return createSemVer({
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch + 1,
+                prerelease: [],
+                build: [],
+            });
+        case 'premajor':
+            return createSemVer({
+                major: version.major + 1,
+                minor: 0,
+                patch: 0,
+                prerelease: [prereleaseId ?? 'alpha', '0'],
+                build: [],
+            });
+        case 'preminor':
+            return createSemVer({
+                major: version.major,
+                minor: version.minor + 1,
+                patch: 0,
+                prerelease: [prereleaseId ?? 'alpha', '0'],
+                build: [],
+            });
+        case 'prepatch':
+            return createSemVer({
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch + 1,
+                prerelease: [prereleaseId ?? 'alpha', '0'],
+                build: [],
+            });
+        case 'prerelease':
+            return incrementPrerelease(version, prereleaseId);
+        case 'none':
+        default:
+            return version;
+    }
+}
+/**
+ * Increments the prerelease portion of a version.
+ *
+ * @param version - The version to increment
+ * @param id - Optional prerelease identifier
+ * @returns A new version with incremented prerelease
+ */
+function incrementPrerelease(version, id) {
+    const prerelease = [...version.prerelease];
+    if (prerelease.length === 0) {
+        // No existing prerelease - start at patch+1 with id.0
+        return createSemVer({
+            major: version.major,
+            minor: version.minor,
+            patch: version.patch + 1,
+            prerelease: [id ?? 'alpha', '0'],
+            build: [],
+        });
+    }
+    // Check if the last identifier is numeric
+    const lastIdx = prerelease.length - 1;
+    const last = prerelease[lastIdx];
+    const lastNum = parseInt(last, 10);
+    if (!globalIsNaN(lastNum)) {
+        // Increment the numeric part
+        prerelease[lastIdx] = String(lastNum + 1);
+    }
+    else {
+        // Append .0
+        prerelease.push('0');
+    }
+    // If a different id is specified, replace the base identifier
+    if (id && prerelease.length > 0 && prerelease[0] !== id) {
+        prerelease[0] = id;
+        // Reset numeric part
+        if (prerelease.length > 1) {
+            prerelease[prerelease.length - 1] = '0';
+        }
+    }
+    return createSemVer({
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch,
+        prerelease,
+        build: [],
+    });
+}
+/**
+ * Calculates the difference type between two versions.
+ *
+ * @param older - The older version
+ * @param newer - The newer version
+ * @returns The type of difference, or null if versions are equal
+ *
+ * @example
+ * diff(parseVersion('1.0.0'), parseVersion('2.0.0')) // 'major'
+ * diff(parseVersion('1.0.0'), parseVersion('1.1.0')) // 'minor'
+ * diff(parseVersion('1.0.0'), parseVersion('1.0.1')) // 'patch'
+ */
+function diff(older, newer) {
+    // Check major
+    if (older.major !== newer.major) {
+        if (newer.prerelease.length > 0) {
+            return 'premajor';
+        }
+        return 'major';
+    }
+    // Check minor
+    if (older.minor !== newer.minor) {
+        if (newer.prerelease.length > 0) {
+            return 'preminor';
+        }
+        return 'minor';
+    }
+    // Check patch
+    if (older.patch !== newer.patch) {
+        if (newer.prerelease.length > 0) {
+            return 'prepatch';
+        }
+        return 'patch';
+    }
+    // Check prerelease
+    if (older.prerelease.length !== newer.prerelease.length) {
+        return 'prerelease';
+    }
+    for (let i = 0; i < older.prerelease.length; i++) {
+        if (older.prerelease[i] !== newer.prerelease[i]) {
+            return 'prerelease';
+        }
+    }
+    // Versions are equal (ignoring build)
+    return null;
+}
+
+/**
+ * Converts a SemVer to its canonical string representation.
+ *
+ * @param version - The version to format
+ * @returns The version string (e.g., "1.2.3-alpha.1+build.123")
+ */
+function format(version) {
+    let result = `${version.major}.${version.minor}.${version.patch}`;
+    if (version.prerelease.length > 0) {
+        result += '-' + version.prerelease.join('.');
+    }
+    if (version.build.length > 0) {
+        result += '+' + version.build.join('.');
+    }
+    return result;
+}
+/**
+ * Converts a SemVer to a string without prerelease/build.
+ *
+ * @param version - The version to format
+ * @returns The version string (e.g., "1.2.3")
+ */
+function formatSimple(version) {
+    return `${version.major}.${version.minor}.${version.patch}`;
+}
+/**
+ * Converts a Range to its string representation.
+ *
+ * @param range - The range to format
+ * @returns The range string
+ */
+function formatRange(range) {
+    if (range.raw) {
+        return range.raw;
+    }
+    if (range.sets.length === 0) {
+        return '*';
+    }
+    return range.sets.map((set) => set.comparators.map((c) => formatComparator(c)).join(' ')).join(' || ');
+}
+/**
+ * Converts a Comparator to its string representation.
+ *
+ * @param comparator - The comparator to format
+ * @returns The comparator string (e.g., ">=1.0.0")
+ */
+function formatComparator(comparator) {
+    const op = comparator.operator === '=' ? '' : comparator.operator;
+    return op + format(comparator.version);
+}
+
+exports.coerceVersion = coerceVersion;
+exports.compare = compare;
+exports.createAnyRange = createAnyRange;
+exports.createComparator = createComparator;
+exports.createComparatorSet = createComparatorSet;
+exports.createExactRange = createExactRange;
+exports.createFirstRelease = createFirstRelease;
+exports.createInitialVersion = createInitialVersion;
+exports.createRange = createRange;
+exports.createSemVer = createSemVer;
+exports.diff = diff;
+exports.eq = eq;
+exports.format = format;
+exports.formatComparator = formatComparator;
+exports.formatRange = formatRange;
+exports.formatSimple = formatSimple;
+exports.gt = gt;
+exports.gte = gte;
+exports.increment = increment;
+exports.incrementPrerelease = incrementPrerelease;
+exports.isPrerelease = isPrerelease;
+exports.isStable = isStable;
+exports.isWildcard = isWildcard;
+exports.lt = lt;
+exports.lte = lte;
+exports.max = max;
+exports.maxSatisfying = maxSatisfying;
+exports.min = min;
+exports.minSatisfying = minSatisfying;
+exports.neq = neq;
+exports.parseRange = parseRange;
+exports.parseRangeStrict = parseRangeStrict;
+exports.parseVersion = parseVersion;
+exports.parseVersionStrict = parseVersionStrict;
+exports.satisfies = satisfies;
+exports.satisfiesComparator = satisfiesComparator;
+exports.sort = sort;
+exports.sortDescending = sortDescending;
+exports.stripBuild = stripBuild;
+exports.stripPrerelease = stripPrerelease;
+//# sourceMappingURL=index.cjs.js.map