@hyperfrontend/versioning 0.1.0

package/changelog/models/index.cjs.js

@@ -0,0 +1,2043 @@
+'use strict';
+
+/**
+ * Creates a new changelog with default values.
+ *
+ * @param options - Optional configuration to customize the changelog
+ * @returns A new Changelog object with the specified options or defaults
+ */
+function createChangelog(options) {
+    return {
+        source: options?.source,
+        header: options?.header ?? {
+            title: '# Changelog',
+            description: [],
+            links: [],
+        },
+        entries: options?.entries ?? [],
+        metadata: options?.metadata ?? {
+            format: 'unknown',
+            isConventional: false,
+            warnings: [],
+        },
+    };
+}
+/**
+ * Creates a new empty changelog with standard header.
+ *
+ * @returns A new empty Changelog with Keep a Changelog format
+ */
+function createEmptyChangelog() {
+    return {
+        header: {
+            title: '# Changelog',
+            description: [
+                'All notable changes to this project will be documented in this file.',
+                '',
+                'The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),',
+                'and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).',
+            ],
+            links: [],
+        },
+        entries: [],
+        metadata: {
+            format: 'keep-a-changelog',
+            isConventional: false,
+            warnings: [],
+        },
+    };
+}
+/**
+ * Creates a changelog link.
+ *
+ * @param label - The display text for the link
+ * @param url - The URL the link points to
+ * @returns A new ChangelogLink object
+ */
+function createChangelogLink(label, url) {
+    return { label, url };
+}
+
+/**
+ * Creates a new changelog item.
+ *
+ * @param description - The description text of the change
+ * @param options - Optional configuration for scope, commits, references, and breaking flag
+ * @returns A new ChangelogItem object
+ */
+function createChangelogItem(description, options) {
+    return {
+        description,
+        scope: options?.scope,
+        commits: options?.commits ?? [],
+        references: options?.references ?? [],
+        breaking: options?.breaking ?? false,
+    };
+}
+/**
+ * Creates a new changelog section.
+ *
+ * @param type - The type of section (features, fixes, breaking, etc.)
+ * @param heading - The display heading for the section
+ * @param items - Optional array of changelog items in this section
+ * @returns A new ChangelogSection object
+ */
+function createChangelogSection(type, heading, items = []) {
+    return {
+        type,
+        heading,
+        items,
+    };
+}
+/**
+ * Creates a new changelog entry.
+ *
+ * @param version - The version string (e.g., '1.0.0')
+ * @param options - Optional configuration for date, sections, and other properties
+ * @returns A new ChangelogEntry object
+ */
+function createChangelogEntry(version, options) {
+    return {
+        version,
+        date: options?.date ?? null,
+        unreleased: options?.unreleased ?? false,
+        compareUrl: options?.compareUrl,
+        sections: options?.sections ?? [],
+        rawContent: options?.rawContent,
+    };
+}
+/**
+ * Creates an unreleased changelog entry.
+ *
+ * @param sections - Optional array of changelog sections
+ * @returns A new ChangelogEntry object marked as unreleased
+ */
+function createUnreleasedEntry(sections = []) {
+    return {
+        version: 'Unreleased',
+        date: null,
+        unreleased: true,
+        sections,
+    };
+}
+
+/**
+ * Maps section headings to their canonical types.
+ * Used during parsing to normalize different heading styles.
+ */
+const SECTION_TYPE_MAP = {
+    // Breaking changes
+    'breaking changes': 'breaking',
+    breaking: 'breaking',
+    'breaking change': 'breaking',
+    // Features
+    features: 'features',
+    feature: 'features',
+    added: 'features',
+    new: 'features',
+    // Fixes
+    fixes: 'fixes',
+    fix: 'fixes',
+    'bug fixes': 'fixes',
+    bugfixes: 'fixes',
+    fixed: 'fixes',
+    // Performance
+    performance: 'performance',
+    'performance improvements': 'performance',
+    perf: 'performance',
+    // Documentation
+    documentation: 'documentation',
+    docs: 'documentation',
+    // Deprecations
+    deprecations: 'deprecations',
+    deprecated: 'deprecations',
+    // Refactoring
+    refactoring: 'refactoring',
+    refactor: 'refactoring',
+    'code refactoring': 'refactoring',
+    // Tests
+    tests: 'tests',
+    test: 'tests',
+    testing: 'tests',
+    // Build
+    build: 'build',
+    'build system': 'build',
+    dependencies: 'build',
+    // CI
+    ci: 'ci',
+    'continuous integration': 'ci',
+    // Chores
+    chores: 'chores',
+    chore: 'chores',
+    maintenance: 'chores',
+    // Other
+    other: 'other',
+    miscellaneous: 'other',
+    misc: 'other',
+    changed: 'other',
+    changes: 'other',
+    removed: 'other',
+    security: 'other',
+};
+/**
+ * Standard section headings for serialization.
+ * Maps section types to their preferred heading text.
+ */
+const SECTION_HEADINGS = {
+    breaking: 'Breaking Changes',
+    features: 'Features',
+    fixes: 'Bug Fixes',
+    performance: 'Performance',
+    documentation: 'Documentation',
+    deprecations: 'Deprecations',
+    refactoring: 'Refactoring',
+    tests: 'Tests',
+    build: 'Build',
+    ci: 'CI',
+    chores: 'Chores',
+    other: 'Other',
+};
+/**
+ * Determines the section type from a heading string.
+ * Returns 'other' if the heading is not recognized.
+ *
+ * @param heading - The heading string to parse
+ * @returns The corresponding ChangelogSectionType
+ */
+function getSectionType(heading) {
+    const normalized = heading.toLowerCase().trim();
+    return SECTION_TYPE_MAP[normalized] ?? 'other';
+}
+
+/**
+ * Creates a commit reference from a full hash.
+ *
+ * @param hash - The full commit hash
+ * @param url - Optional URL to the commit
+ * @returns A new CommitRef object with both full and short hash
+ */
+function createCommitRef(hash, url) {
+    return {
+        hash,
+        shortHash: hash.slice(0, 7),
+        url,
+    };
+}
+/**
+ * Creates an issue reference.
+ *
+ * @param number - The issue or PR number
+ * @param type - The type of reference ('issue' or 'pull-request')
+ * @param url - Optional URL to the issue or PR
+ * @returns A new IssueRef object
+ */
+function createIssueRef(number, type = 'issue', url) {
+    return {
+        number,
+        type,
+        url,
+    };
+}
+/**
+ * Extracts the short hash from a full commit hash.
+ *
+ * @param hash - The full commit hash
+ * @returns The first 7 characters of the hash
+ */
+function getShortHash(hash) {
+    return hash.slice(0, 7);
+}
+
+/**
+ * Safe copies of Set built-in via factory function.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses 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/set
+ */
+// Capture references at module initialization time
+const _Set = globalThis.Set;
+const _Reflect$5 = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Set using the captured Set constructor.
+ * Use this instead of `new Set()`.
+ *
+ * @param iterable - Optional iterable of values.
+ * @returns A new Set instance.
+ */
+const createSet = (iterable) => _Reflect$5.construct(_Set, iterable ? [iterable] : []);
+
+/**
+ * Safe copies of Array built-in static 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/array
+ */
+// Capture references at module initialization time
+const _Array = globalThis.Array;
+/**
+ * (Safe copy) Determines whether the passed value is an Array.
+ */
+const isArray = _Array.isArray;
+
+/**
+ * Safe copies of Map built-in via factory function.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses 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/map
+ */
+// Capture references at module initialization time
+const _Map = globalThis.Map;
+const _Reflect$4 = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Map using the captured Map constructor.
+ * Use this instead of `new Map()`.
+ *
+ * @param iterable - Optional iterable of key-value pairs.
+ * @returns A new Map instance.
+ */
+const createMap = (iterable) => _Reflect$4.construct(_Map, iterable ? [iterable] : []);
+
+/**
+ * Safe copies of Object 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/object
+ */
+// Capture references at module initialization time
+const _Object = globalThis.Object;
+const _Reflect$3 = globalThis.Reflect;
+const _ObjectPrototype = _Object.prototype;
+const _hasOwnProperty = _ObjectPrototype.hasOwnProperty;
+/**
+ * (Safe copy) Returns the names of the enumerable string properties and methods of an object.
+ */
+const keys = _Object.keys;
+/**
+ * (Safe copy) Returns an array of key/values of the enumerable own properties of an object.
+ */
+const entries = _Object.entries;
+/**
+ * (Safe copy) Adds a property to an object, or modifies attributes of an existing property.
+ */
+const defineProperty = _Object.defineProperty;
+/**
+ * (Safe copy) Safe wrapper for Object.prototype.hasOwnProperty.call().
+ * Checks if an object has a property as its own (not inherited) property.
+ *
+ * @param obj - The object to check.
+ * @param key - The property key to check.
+ * @returns True if the object has the property as its own property.
+ */
+const hasOwn = (obj, key) => _Reflect$3.apply(_hasOwnProperty, obj, [key]);
+
+/**
+ * Creates a new validation context.
+ *
+ * @param rootSchema - The root schema being validated against
+ * @param validator - The schema validator function
+ * @param collectAllErrors - Whether to collect all errors (default: true)
+ * @param strictPatterns - Whether to report errors for invalid regex patterns (default: false)
+ * @param patternSafetyChecker - Optional pattern safety checker for ReDoS detection
+ * @returns A new validation context
+ */
+function createValidationContext(rootSchema, validator, collectAllErrors = true, strictPatterns = false, patternSafetyChecker) {
+    const definitions = createMap();
+    // Pre-populate definitions from root schema
+    if (rootSchema.definitions) {
+        for (const [name, schema] of entries(rootSchema.definitions)) {
+            definitions.set(`#/definitions/${name}`, schema);
+        }
+    }
+    return {
+        path: '',
+        errors: [],
+        rootSchema,
+        definitions,
+        collectAllErrors,
+        strictPatterns,
+        patternSafetyChecker,
+        validate: validator,
+    };
+}
+/**
+ * Creates a child context with updated path.
+ *
+ * @param ctx - Parent context
+ * @param segment - Path segment to append
+ * @returns New context with updated path
+ */
+function pushPath(ctx, segment) {
+    const escapedSegment = String(segment).replace(/~/g, '~0').replace(/\//g, '~1');
+    return {
+        ...ctx,
+        path: `${ctx.path}/${escapedSegment}`,
+    };
+}
+/**
+ * Adds a validation error to the context.
+ *
+ * @param ctx - Validation context
+ * @param message - Human-readable error message
+ * @param instance - The failing value
+ * @param code - Optional error code for programmatic handling
+ * @param params - Optional additional parameters
+ */
+function addError(ctx, message, instance, code, params) {
+    ctx.errors.push({
+        message,
+        path: ctx.path || '/',
+        instance,
+        code,
+        params,
+    });
+}
+/**
+ * Checks if we should continue validation after an error.
+ *
+ * @param ctx - Validation context
+ * @returns true if we should continue, false if we should stop
+ */
+function shouldContinue(ctx) {
+    return ctx.collectAllErrors || ctx.errors.length === 0;
+}
+
+/**
+ * Performs deep equality check for JSON values.
+ *
+ * Used for enum validation and uniqueItems validation.
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns true if values are deeply equal, false otherwise
+ */
+function isEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a === 'object') {
+        if (isArray(a) && isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!isEqual(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        if (isArray(a) || isArray(b))
+            return false;
+        const keysA = keys(a);
+        const keysB = keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!hasOwn(b, key))
+                return false;
+            if (!isEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Validates array length and uniqueItems constraints.
+ *
+ * @param instance - Array being validated
+ * @param schema - Schema containing array bounds
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateArrayBounds(instance, schema, ctx) {
+    let valid = true;
+    if (schema.minItems !== undefined && instance.length < schema.minItems) {
+        addError(ctx, `Array must have at least ${schema.minItems} items, got ${instance.length}`, instance, 'minItems', {
+            limit: schema.minItems,
+            actual: instance.length,
+        });
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (schema.maxItems !== undefined && instance.length > schema.maxItems) {
+        addError(ctx, `Array must have at most ${schema.maxItems} items, got ${instance.length}`, instance, 'maxItems', {
+            limit: schema.maxItems,
+            actual: instance.length,
+        });
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (schema.uniqueItems === true) {
+        // Check for duplicates
+        for (let i = 0; i < instance.length; i++) {
+            for (let j = i + 1; j < instance.length; j++) {
+                if (isEqual(instance[i], instance[j])) {
+                    addError(ctx, `Array items must be unique. Duplicate found at indices ${i} and ${j}`, instance, 'uniqueItems');
+                    valid = false;
+                    if (!shouldContinue(ctx))
+                        return false;
+                }
+            }
+        }
+    }
+    return valid;
+}
+
+/**
+ * Validates 'allOf' keyword - all schemas must match.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema containing the allOf constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateAllOf(instance, schema, ctx) {
+    const allOf = schema.allOf;
+    if (!allOf || allOf.length === 0) {
+        return true;
+    }
+    let valid = true;
+    for (let i = 0; i < allOf.length; i++) {
+        const subSchema = allOf[i];
+        /* istanbul ignore if -- defensive null check for sparse arrays */
+        if (!subSchema)
+            continue;
+        if (!ctx.validate(instance, subSchema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    return valid;
+}
+/**
+ * Validates 'anyOf' keyword - at least one schema must match.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema containing the anyOf constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateAnyOf(instance, schema, ctx) {
+    const anyOf = schema.anyOf;
+    if (!anyOf || anyOf.length === 0) {
+        return true;
+    }
+    // Try each schema - if any matches, we pass
+    for (const subSchema of anyOf) {
+        const subCtx = createValidationContext(ctx.rootSchema, ctx.validate, false);
+        // Copy path from parent context
+        defineProperty(subCtx, 'path', { value: ctx.path, writable: false });
+        if (ctx.validate(instance, subSchema, subCtx)) {
+            return true;
+        }
+    }
+    addError(ctx, 'Value does not match any of the allowed schemas (anyOf)', instance, 'anyOf');
+    return false;
+}
+/**
+ * Validates 'oneOf' keyword - exactly one schema must match.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema containing the oneOf constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateOneOf(instance, schema, ctx) {
+    const oneOf = schema.oneOf;
+    if (!oneOf || oneOf.length === 0) {
+        return true;
+    }
+    let matchCount = 0;
+    for (const subSchema of oneOf) {
+        const subCtx = createValidationContext(ctx.rootSchema, ctx.validate, false);
+        defineProperty(subCtx, 'path', { value: ctx.path, writable: false });
+        if (ctx.validate(instance, subSchema, subCtx)) {
+            matchCount++;
+            if (matchCount > 1)
+                break; // Early exit if more than one match
+        }
+    }
+    if (matchCount === 1) {
+        return true;
+    }
+    if (matchCount === 0) {
+        addError(ctx, 'Value does not match any of the schemas (oneOf)', instance, 'oneOf');
+    }
+    else {
+        addError(ctx, `Value matches ${matchCount} schemas but must match exactly one (oneOf)`, instance, 'oneOf', {
+            matches: matchCount,
+        });
+    }
+    return false;
+}
+/**
+ * Validates 'not' keyword - schema must NOT match.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema containing the not constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateNot(instance, schema, ctx) {
+    const not = schema.not;
+    if (!not) {
+        return true;
+    }
+    const subCtx = createValidationContext(ctx.rootSchema, ctx.validate, false);
+    defineProperty(subCtx, 'path', { value: ctx.path, writable: false });
+    if (ctx.validate(instance, not, subCtx)) {
+        // Schema matched when it shouldn't have
+        addError(ctx, 'Value should NOT match the schema', instance, 'not');
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Validates object 'dependencies' keyword.
+ *
+ * @param instance - Object being validated
+ * @param schema - Schema containing the dependencies constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateDependencies(instance, schema, ctx) {
+    if (!schema.dependencies) {
+        return true;
+    }
+    let valid = true;
+    for (const [key, dependency] of entries(schema.dependencies)) {
+        // Only check dependency if the key is present
+        /* istanbul ignore next -- key presence check */
+        if (!hasOwn(instance, key)) {
+            continue;
+        }
+        /* istanbul ignore next -- dependency type check */
+        if (isArray(dependency)) {
+            // Property dependency: if key is present, these properties must also be present
+            for (const requiredKey of dependency) {
+                /* istanbul ignore next -- required key check */
+                if (!hasOwn(instance, requiredKey)) {
+                    addError(ctx, `Property '${key}' requires property '${requiredKey}' to also be present`, instance, 'dependencies', {
+                        property: key,
+                        /* istanbul ignore next -- required key assignment */
+                        required: requiredKey,
+                    });
+                    valid = false;
+                    /* istanbul ignore if -- early exit tested in validate.spec.ts */
+                    if (!shouldContinue(ctx))
+                        return false;
+                }
+            }
+        }
+        else {
+            // Schema dependency: if key is present, the object must also validate against this schema
+            /* istanbul ignore next -- schema dependency validation */
+            if (!ctx.validate(instance, dependency, ctx)) {
+                /* istanbul ignore next -- failure path */
+                valid = false;
+                /* istanbul ignore if -- early exit tested in validate.spec.ts */
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+    }
+    return valid;
+}
+
+/**
+ * Safe copies of JSON 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/json
+ */
+// Capture references at module initialization time
+const _JSON = globalThis.JSON;
+/**
+ * (Safe copy) Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ */
+const stringify = _JSON.stringify;
+
+/**
+ * Validates enum constraint.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema containing the enum constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateEnum(instance, schema, ctx) {
+    if (!schema.enum) {
+        return true;
+    }
+    for (const enumValue of schema.enum) {
+        if (isEqual(instance, enumValue)) {
+            return true;
+        }
+    }
+    const allowedValues = schema.enum.map((v) => stringify(v)).join(', ');
+    addError(ctx, `Value must be one of: ${allowedValues}`, instance, 'enum', {
+        allowedValues: schema.enum,
+    });
+    return false;
+}
+
+/**
+ * Safe copies of Date built-in via factory function and static methods.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses 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/date
+ */
+// Capture references at module initialization time
+const _Date = globalThis.Date;
+const _Reflect$2 = globalThis.Reflect;
+function createDate(...args) {
+    return _Reflect$2.construct(_Date, args);
+}
+/**
+ * (Safe copy) Parses a string representation of a date.
+ */
+const dateParse = _Date.parse;
+/**
+ * (Safe copy) Returns the number of milliseconds in a Date object since January 1, 1970 UTC.
+ */
+const dateUTC = _Date.UTC;
+
+/**
+ * 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 _Number = globalThis.Number;
+const _parseInt = globalThis.parseInt;
+const _isNaN = globalThis.isNaN;
+const _isFinite = globalThis.isFinite;
+/**
+ * (Safe copy) Determines whether the passed value is an integer.
+ */
+const isInteger = _Number.isInteger;
+// ============================================================================
+// 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;
+/**
+ * (Safe copy) Global isFinite function (coerces to number first, less strict than Number.isFinite).
+ */
+const globalIsFinite = _isFinite;
+
+/**
+ * Safe copies of RegExp built-in via factory function.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses 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/regexp
+ */
+// Capture references at module initialization time
+const _RegExp = globalThis.RegExp;
+const _Reflect$1 = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new RegExp using the captured RegExp constructor.
+ * Use this instead of `new RegExp()`.
+ *
+ * @param pattern - The pattern string or RegExp to copy.
+ * @param flags - Optional flags string.
+ * @returns A new RegExp instance.
+ */
+const createRegExp = (pattern, flags) => _Reflect$1.construct(_RegExp, [pattern, flags]);
+
+/**
+ * Safe copies of URL built-ins via factory functions.
+ *
+ * Provides safe references to URL and URLSearchParams.
+ * 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/url
+ */
+// Capture references at module initialization time
+const _URL = globalThis.URL;
+const _Reflect = globalThis.Reflect;
+// ============================================================================
+// URL
+// ============================================================================
+/**
+ * (Safe copy) Creates a new URL using the captured URL constructor.
+ * Use this instead of `new URL()`.
+ *
+ * @param url - The URL string to parse.
+ * @param base - Optional base URL for relative URLs.
+ * @returns A new URL instance.
+ */
+const createURL = (url, base) => _Reflect.construct(_URL, [url, base]);
+/**
+ * (Safe copy) Creates an object URL for the given object.
+ * Use this instead of `URL.createObjectURL()`.
+ *
+ * Note: This is a browser-only API. In Node.js environments, this will throw.
+ */
+typeof _URL.createObjectURL === 'function'
+    ? _URL.createObjectURL.bind(_URL)
+    : () => {
+        throw new Error('URL.createObjectURL is not available in this environment');
+    };
+/**
+ * (Safe copy) Revokes an object URL previously created with createObjectURL.
+ * Use this instead of `URL.revokeObjectURL()`.
+ *
+ * Note: This is a browser-only API. In Node.js environments, this will throw.
+ */
+typeof _URL.revokeObjectURL === 'function'
+    ? _URL.revokeObjectURL.bind(_URL)
+    : () => {
+        throw new Error('URL.revokeObjectURL is not available in this environment');
+    };
+
+/**
+ * Format validators for common string formats.
+ */
+const formatValidators = {
+    'date-time': (v) => {
+        // ISO 8601 date-time format - anchored to prevent matching at unexpected locations
+        if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(v))
+            return false;
+        const date = dateParse(v);
+        return !globalIsNaN(date);
+    },
+    date: (v) => {
+        // ISO 8601 date format (YYYY-MM-DD)
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(v))
+            return false;
+        const [year, month, day] = v.split('-').map(Number);
+        const date = createDate(dateUTC(year, month - 1, day));
+        // Check that the date components match exactly
+        return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+    },
+    time: (v) => {
+        // ISO 8601 time format (HH:MM:SS or HH:MM:SS.sss with optional timezone)
+        // Parse segments to avoid nested quantifiers
+        const mainMatch = v.match(/^(\d{2}):(\d{2}):(\d{2})/);
+        if (!mainMatch)
+            return false;
+        const hour = Number(mainMatch[1]);
+        const minute = Number(mainMatch[2]);
+        const second = Number(mainMatch[3]);
+        if (hour > 23 || minute > 59 || second > 59)
+            return false;
+        // Validate remaining part (fractional seconds and/or timezone)
+        const rest = v.slice(8);
+        if (rest === '')
+            return true;
+        // Fractional seconds: .ddd where d is digits (1-6 typically)
+        if (rest.match(/^\.\d{1,9}$/))
+            return true;
+        // Timezone only: Z or +HH:MM or -HH:MM
+        if (rest.match(/^(Z|[+-]\d{2}:\d{2})$/))
+            return true;
+        // Fractional + timezone
+        if (rest.match(/^\.\d{1,9}(Z|[+-]\d{2}:\d{2})$/))
+            return true;
+        return false;
+    },
+    email: (v) => {
+        // Basic email validation - fixed to prevent ReDoS by excluding dots from domain part
+        return /^[^\s@]+@[^\s@.]+\.[^\s@.]+$/.test(v);
+    },
+    hostname: (v) => {
+        // RFC 1123 hostname - validated per label to prevent ReDoS
+        if (v.length > 253 || v.length === 0)
+            return false; // Max hostname length per RFC
+        const labels = v.split('.');
+        for (const label of labels) {
+            if (label.length === 0 || label.length > 63)
+                return false;
+            // Start and end with alphanumeric
+            if (!/^[a-zA-Z0-9]$/.test(label[0]))
+                return false;
+            if (label.length > 1 && !/^[a-zA-Z0-9]$/.test(label[label.length - 1]))
+                return false;
+            // Middle can include hyphens
+            for (let i = 1; i < label.length - 1; i++) {
+                if (!/^[a-zA-Z0-9-]$/.test(label[i]))
+                    return false;
+            }
+        }
+        return true;
+    },
+    ipv4: (v) => {
+        // IPv4 address
+        const parts = v.split('.');
+        if (parts.length !== 4)
+            return false;
+        return parts.every((part) => {
+            const num = parseInt(part, 10);
+            return !globalIsNaN(num) && num >= 0 && num <= 255 && part === String(num);
+        });
+    },
+    ipv6: (v) => {
+        // Simplified IPv6 validation - procedural approach to avoid ReDoS
+        if (v === '::')
+            return true;
+        // Check for double colon (compressed form)
+        const hasDoubleColon = v.includes('::');
+        if (!hasDoubleColon) {
+            // Full form: exactly 8 groups separated by single colons
+            const groups = v.split(':');
+            if (groups.length !== 8)
+                return false;
+            const hexGroup = /^[0-9a-fA-F]{1,4}$/;
+            return groups.every((g) => hexGroup.test(g));
+        }
+        // Compressed form: validate :: appears exactly once and total groups <= 8
+        const parts = v.split('::');
+        if (parts.length !== 2)
+            return false;
+        const left = parts[0] ? parts[0].split(':').filter(Boolean) : [];
+        const right = parts[1] ? parts[1].split(':').filter(Boolean) : [];
+        if (left.length + right.length > 7)
+            return false;
+        const hexGroup = /^[0-9a-fA-F]{1,4}$/;
+        return left.every((g) => hexGroup.test(g)) && right.every((g) => hexGroup.test(g));
+    },
+    uri: (v) => {
+        // Basic URI validation
+        try {
+            createURL(v);
+            return true;
+            /* istanbul ignore next -- URL constructor always throws for invalid URI */
+        }
+        catch {
+            return false;
+        }
+    },
+    'uri-reference': (v) => {
+        // URI or relative reference
+        try {
+            createURL(v, 'http://example.com');
+            /* istanbul ignore next -- success path just returns true */
+            return true;
+        }
+        catch {
+            /* istanbul ignore next -- URL constructor is very permissive with base URL */
+            return false;
+        }
+    },
+    uuid: (v) => {
+        // UUID format
+        return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(v);
+    },
+    regex: (v) => {
+        // Valid regex pattern
+        try {
+            // eslint-disable-next-line workspace/no-unsafe-regex -- intentionally validating user-provided regex patterns
+            createRegExp(v);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    'json-pointer': (v) => {
+        // JSON Pointer format - validate segment by segment to avoid nested quantifiers
+        if (v === '')
+            return true;
+        if (!v.startsWith('/'))
+            return false;
+        const segments = v.slice(1).split('/');
+        const validSegment = /^([^/~]|~[01])*$/;
+        return segments.every((seg) => validSegment.test(seg));
+    },
+};
+/**
+ * Validates string format constraint.
+ *
+ * @param instance - String being validated
+ * @param schema - Schema containing the format constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateFormat(instance, schema, ctx) {
+    if (!schema.format) {
+        return true;
+    }
+    const validator = formatValidators[schema.format];
+    if (!validator) {
+        // Unknown format - allow by default (as per JSON Schema spec)
+        return true;
+    }
+    if (!validator(instance)) {
+        addError(ctx, `String does not match format '${schema.format}'`, instance, 'format', {
+            format: schema.format,
+        });
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Validates array 'items' keyword.
+ *
+ * @param instance - Array being validated
+ * @param schema - Schema containing the items constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateItems(instance, schema, ctx) {
+    const items = schema.items;
+    if (items === undefined) {
+        return true;
+    }
+    let valid = true;
+    if (isArray(items)) {
+        // Tuple validation
+        for (let i = 0; i < items.length && i < instance.length; i++) {
+            const itemSchema = items[i];
+            /* istanbul ignore if -- defensive null check for sparse arrays */
+            if (!itemSchema)
+                continue;
+            const itemCtx = pushPath(ctx, i);
+            if (!ctx.validate(instance[i], itemSchema, itemCtx)) {
+                valid = false;
+                /* istanbul ignore if -- early exit already tested in validate.spec.ts */
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+        // Handle additional items beyond the tuple
+        if (instance.length > items.length) {
+            if (!validateAdditionalItems(instance, schema, ctx, items.length)) {
+                valid = false;
+            }
+        }
+    }
+    else {
+        // All items must match the single schema
+        for (let i = 0; i < instance.length; i++) {
+            const itemCtx = pushPath(ctx, i);
+            if (!ctx.validate(instance[i], items, itemCtx)) {
+                valid = false;
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+    }
+    return valid;
+}
+/**
+ * Validates 'additionalItems' keyword for tuple arrays.
+ *
+ * @param instance - Array being validated
+ * @param schema - Schema containing the additionalItems constraint
+ * @param ctx - Validation context
+ * @param startIndex - Index from which to start checking additional items
+ * @returns true if validation passes, false otherwise
+ */
+function validateAdditionalItems(instance, schema, ctx, startIndex) {
+    const additionalItems = schema.additionalItems;
+    // If not specified, additional items are allowed
+    /* istanbul ignore if -- default case handled in items.spec.ts */
+    if (additionalItems === undefined) {
+        return true;
+    }
+    /* istanbul ignore next -- additionalItems initialization and branching */
+    let valid = true;
+    /* istanbul ignore next -- additionalItems branching */
+    if (additionalItems === false) {
+        // No additional items allowed
+        if (instance.length > startIndex) {
+            addError(ctx, `Array has too many items. Expected at most ${startIndex}, got ${instance.length}`, instance, 'additionalItems', {
+                limit: startIndex,
+                actual: instance.length,
+            });
+            valid = false;
+        }
+    }
+    else if (typeof additionalItems === 'object') {
+        // Additional items must match the schema
+        for (let i = startIndex; i < instance.length; i++) {
+            const itemCtx = pushPath(ctx, i);
+            /* istanbul ignore else -- validation failure tested in items.spec.ts */
+            if (!ctx.validate(instance[i], additionalItems, itemCtx)) {
+                valid = false;
+                /* istanbul ignore if -- early exit tested in validate.spec.ts */
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+    }
+    // If additionalItems === true, any additional items are allowed
+    return valid;
+}
+
+/**
+ * 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;
+// ============================================================================
+// Basic Operations
+// ============================================================================
+/**
+ * (Safe copy) Returns the absolute value of a number.
+ */
+const abs = _Math.abs;
+
+/**
+ * Validates number range and multipleOf constraints.
+ *
+ * @param instance - Number being validated
+ * @param schema - Schema containing number constraints
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateNumberBounds(instance, schema, ctx) {
+    let valid = true;
+    if (schema.minimum !== undefined) {
+        const isExclusive = schema.exclusiveMinimum === true;
+        if (isExclusive ? instance <= schema.minimum : instance < schema.minimum) {
+            const comparison = isExclusive ? 'greater than' : 'at least';
+            addError(ctx, `Number must be ${comparison} ${schema.minimum}, got ${instance}`, instance, 'minimum', {
+                limit: schema.minimum,
+                exclusive: isExclusive,
+                actual: instance,
+            });
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    if (schema.maximum !== undefined) {
+        const isExclusive = schema.exclusiveMaximum === true;
+        if (isExclusive ? instance >= schema.maximum : instance > schema.maximum) {
+            const comparison = isExclusive ? 'less than' : 'at most';
+            addError(ctx, `Number must be ${comparison} ${schema.maximum}, got ${instance}`, instance, 'maximum', {
+                limit: schema.maximum,
+                exclusive: isExclusive,
+                actual: instance,
+            });
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    if (schema.multipleOf !== undefined && schema.multipleOf > 0) {
+        // Use epsilon comparison for floating point precision
+        const remainder = abs(instance % schema.multipleOf);
+        const epsilon = 1e-10;
+        if (remainder > epsilon && schema.multipleOf - remainder > epsilon) {
+            addError(ctx, `Number must be a multiple of ${schema.multipleOf}, got ${instance}`, instance, 'multipleOf', {
+                multipleOf: schema.multipleOf,
+                actual: instance,
+            });
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    return valid;
+}
+
+/**
+ * Validates object bounds constraints (minProperties, maxProperties).
+ *
+ * @param instance - Object being validated
+ * @param schema - Schema containing object bounds
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateObjectBounds(instance, schema, ctx) {
+    let valid = true;
+    const propertyCount = keys(instance).length;
+    if (schema.minProperties !== undefined && propertyCount < schema.minProperties) {
+        addError(ctx, `Object must have at least ${schema.minProperties} properties, got ${propertyCount}`, instance, 'minProperties', {
+            limit: schema.minProperties,
+            actual: propertyCount,
+        });
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (schema.maxProperties !== undefined && propertyCount > schema.maxProperties) {
+        addError(ctx, `Object must have at most ${schema.maxProperties} properties, got ${propertyCount}`, instance, 'maxProperties', {
+            limit: schema.maxProperties,
+            actual: propertyCount,
+        });
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    return valid;
+}
+
+/**
+ * Validates object 'patternProperties' keyword.
+ *
+ * @param instance - Object being validated
+ * @param schema - Schema containing the patternProperties constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validatePatternProperties(instance, schema, ctx) {
+    if (!schema.patternProperties) {
+        return true;
+    }
+    let valid = true;
+    const patterns = [];
+    // Pre-compile all patterns
+    for (const [pattern, patternSchema] of entries(schema.patternProperties)) {
+        // Check pattern safety if a checker is configured
+        /* istanbul ignore if -- patternSafetyChecker branch tested in validate.spec.ts */
+        if (ctx.patternSafetyChecker) {
+            const safetyResult = ctx.patternSafetyChecker(pattern);
+            if (!safetyResult.safe) {
+                addError(ctx, `Unsafe regex pattern in patternProperties: ${safetyResult.reason ?? 'Pattern may cause ReDoS'}`, instance, 'patternProperties', {
+                    pattern,
+                    reason: safetyResult.reason,
+                });
+                valid = false;
+                if (!shouldContinue(ctx))
+                    return false;
+                continue; // Skip this unsafe pattern
+            }
+        }
+        try {
+            // eslint-disable-next-line workspace/no-unsafe-regex -- Pattern safety validated above when safePatterns enabled
+            patterns.push({ regex: createRegExp(pattern), schema: patternSchema });
+        }
+        catch (e) {
+            // Invalid regex
+            /* istanbul ignore next -- strictPatterns mode verified in validate.spec.ts */
+            if (ctx.strictPatterns) {
+                /* istanbul ignore next -- error reporting for invalid regex */
+                addError(ctx, `Invalid regex pattern in patternProperties: ${pattern}`, instance, 'patternProperties', {
+                    /* istanbul ignore next -- error message extraction */
+                    pattern,
+                    /* istanbul ignore next -- ternary expression */
+                    error: e instanceof Error ? e.message : 'Invalid regex',
+                });
+                valid = false;
+                /* istanbul ignore if -- early exit tested in validate.spec.ts */
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+            // Otherwise skip silently
+        }
+    }
+    // Check each property against matching patterns
+    for (const key of keys(instance)) {
+        for (const { regex, schema: patternSchema } of patterns) {
+            if (regex.test(key)) {
+                const propCtx = pushPath(ctx, key);
+                if (!ctx.validate(instance[key], patternSchema, propCtx)) {
+                    valid = false;
+                    if (!shouldContinue(ctx))
+                        return false;
+                }
+            }
+        }
+    }
+    return valid;
+}
+
+/**
+ * Validates object 'properties' keyword.
+ *
+ * @param instance - Object being validated
+ * @param schema - Schema containing the properties constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateProperties(instance, schema, ctx) {
+    if (!schema.properties) {
+        return true;
+    }
+    let valid = true;
+    for (const [key, propSchema] of entries(schema.properties)) {
+        if (hasOwn(instance, key)) {
+            const propCtx = pushPath(ctx, key);
+            if (!ctx.validate(instance[key], propSchema, propCtx)) {
+                valid = false;
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+    }
+    return valid;
+}
+/**
+ * Validates object 'required' keyword.
+ *
+ * @param instance - Object being validated
+ * @param schema - Schema containing the required constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateRequired(instance, schema, ctx) {
+    if (!schema.required) {
+        return true;
+    }
+    let valid = true;
+    for (const key of schema.required) {
+        if (!hasOwn(instance, key)) {
+            addError(ctx, `Missing required property: ${key}`, undefined, 'required', { missing: key });
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    return valid;
+}
+/**
+ * Validates object 'additionalProperties' keyword.
+ *
+ * @param instance - Object being validated
+ * @param schema - Schema containing the additionalProperties constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateAdditionalProperties(instance, schema, ctx) {
+    const additionalProperties = schema.additionalProperties;
+    if (additionalProperties === undefined) {
+        return true;
+    }
+    /* istanbul ignore next -- definedKeys initialization */
+    // Collect defined property names
+    const definedKeys = createSet();
+    /* istanbul ignore next -- schema.properties may not exist */
+    if (schema.properties) {
+        for (const key of keys(schema.properties)) {
+            definedKeys.add(key);
+        }
+    }
+    // Collect pattern property regexes
+    const patterns = [];
+    /* istanbul ignore next -- patternProperties may not always be present */
+    if (schema.patternProperties) {
+        for (const pattern of keys(schema.patternProperties)) {
+            // Skip unsafe patterns if a checker is configured (already reported in patternProperties validator)
+            if (ctx.patternSafetyChecker) {
+                const safetyResult = ctx.patternSafetyChecker(pattern);
+                if (!safetyResult.safe) {
+                    continue; // Skip this unsafe pattern
+                }
+            }
+            try {
+                // eslint-disable-next-line workspace/no-unsafe-regex -- Pattern safety validated above when safePatterns enabled
+                patterns.push(createRegExp(pattern));
+                /* istanbul ignore next -- invalid regex patterns handled in patternProperties validator */
+            }
+            catch {
+                // Invalid regex, skip
+            }
+        }
+    }
+    let valid = true;
+    for (const key of keys(instance)) {
+        // Skip if property is defined in 'properties'
+        if (definedKeys.has(key)) {
+            continue;
+        }
+        // Skip if property matches any pattern in 'patternProperties'
+        if (patterns.some((p) => p.test(key))) {
+            continue;
+        }
+        // This is an additional property
+        if (additionalProperties === false) {
+            addError(ctx, `Additional property not allowed: ${key}`, instance[key], 'additionalProperties', {
+                property: key,
+            });
+            valid = false;
+            /* istanbul ignore if -- early exit tested in validate.spec.ts */
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        else if (typeof additionalProperties === 'object') {
+            const propCtx = pushPath(ctx, key);
+            if (!ctx.validate(instance[key], additionalProperties, propCtx)) {
+                valid = false;
+                /* istanbul ignore if -- early exit tested in validate.spec.ts */
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+        // If additionalProperties === true, any additional property is allowed
+    }
+    return valid;
+}
+
+/**
+ * Validates string length and pattern constraints.
+ *
+ * @param instance - String being validated
+ * @param schema - Schema containing string constraints
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateStringBounds(instance, schema, ctx) {
+    let valid = true;
+    if (schema.minLength !== undefined && instance.length < schema.minLength) {
+        addError(ctx, `String must be at least ${schema.minLength} characters, got ${instance.length}`, instance, 'minLength', {
+            limit: schema.minLength,
+            actual: instance.length,
+        });
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (schema.maxLength !== undefined && instance.length > schema.maxLength) {
+        addError(ctx, `String must be at most ${schema.maxLength} characters, got ${instance.length}`, instance, 'maxLength', {
+            limit: schema.maxLength,
+            actual: instance.length,
+        });
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (schema.pattern !== undefined) {
+        // Check pattern safety if a checker is configured
+        if (ctx.patternSafetyChecker) {
+            const safetyResult = ctx.patternSafetyChecker(schema.pattern);
+            if (!safetyResult.safe) {
+                addError(ctx, `Unsafe regex pattern: ${safetyResult.reason ?? 'Pattern may cause ReDoS'}`, instance, 'pattern', {
+                    pattern: schema.pattern,
+                    reason: safetyResult.reason,
+                });
+                valid = false;
+                if (!shouldContinue(ctx))
+                    return false;
+                // Skip executing the unsafe pattern
+                return valid;
+            }
+        }
+        try {
+            // eslint-disable-next-line workspace/no-unsafe-regex -- Pattern safety validated above when safePatterns enabled
+            const regex = createRegExp(schema.pattern);
+            if (!regex.test(instance)) {
+                addError(ctx, `String does not match pattern: ${schema.pattern}`, instance, 'pattern', {
+                    pattern: schema.pattern,
+                });
+                valid = false;
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+        }
+        catch (e) {
+            // Invalid regex pattern
+            /* istanbul ignore next -- strictPatterns mode verified in validate.spec.ts */
+            if (ctx.strictPatterns) {
+                /* istanbul ignore next -- error reporting for invalid regex */
+                addError(ctx, `Invalid regex pattern: ${schema.pattern}`, instance, 'pattern', {
+                    pattern: schema.pattern,
+                    /* istanbul ignore next -- error message extraction ternary */
+                    error: e instanceof Error ? e.message : 'Invalid regex',
+                });
+                valid = false;
+                /* istanbul ignore if -- early exit tested in validate.spec.ts */
+                if (!shouldContinue(ctx))
+                    return false;
+            }
+            // Otherwise skip validation silently
+        }
+    }
+    return valid;
+}
+
+/**
+ * Type checking functions for JSON Schema types.
+ */
+const typeCheckers = {
+    string: (v) => typeof v === 'string',
+    number: (v) => typeof v === 'number' && globalIsFinite(v),
+    integer: (v) => typeof v === 'number' && globalIsFinite(v) && isInteger(v),
+    boolean: (v) => typeof v === 'boolean',
+    array: (v) => isArray(v),
+    object: (v) => v !== null && typeof v === 'object' && !isArray(v),
+    null: (v) => v === null,
+};
+/**
+ * Gets the actual JSON type of a value for error messages.
+ *
+ * @param value - The value to get the type of
+ * @returns The JSON type as a string
+ */
+function getActualType(value) {
+    if (value === null)
+        return 'null';
+    if (isArray(value))
+        return 'array';
+    const t = typeof value;
+    if (t === 'number') {
+        const num = value;
+        /* istanbul ignore next -- NaN/Infinity edge case */
+        if (!globalIsFinite(num))
+            return 'number'; // NaN/Infinity
+        return isInteger(num) ? 'integer' : 'number';
+    }
+    return t;
+}
+/**
+ * Validates the 'type' keyword.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema containing the type constraint
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateType(instance, schema, ctx) {
+    const schemaType = schema.type;
+    if (schemaType === undefined) {
+        return true;
+    }
+    const types = isArray(schemaType) ? schemaType : [schemaType];
+    for (const type of types) {
+        const checker = typeCheckers[type];
+        /* istanbul ignore if -- defensive check for unknown type */
+        if (checker && checker(instance)) {
+            // Special case: 'integer' should also pass 'number' check
+            return true;
+        }
+        // If type is 'number' and value is an integer, it's still valid
+        /* istanbul ignore if -- defensive fallback for integer/number coercion */
+        if (type === 'number' && typeCheckers['integer']?.(instance)) {
+            return true;
+        }
+    }
+    const actualType = getActualType(instance);
+    const expectedTypes = types.join(' or ');
+    addError(ctx, `Expected type ${expectedTypes} but got ${actualType}`, instance, 'type', {
+        expected: types,
+        actual: actualType,
+    });
+    return false;
+}
+
+/**
+ * Resolves a $ref JSON Pointer to its target schema.
+ *
+ * @param ref - The $ref string (e.g., '#/definitions/Address')
+ * @param ctx - Validation context containing root schema and definitions
+ * @returns The resolved schema, or undefined if not found
+ */
+function resolveRef(ref, ctx) {
+    // Check pre-populated definitions first
+    const cached = ctx.definitions.get(ref);
+    if (cached) {
+        return cached;
+    }
+    // Only support internal references (starting with #)
+    if (!ref.startsWith('#')) {
+        return undefined;
+    }
+    // Handle root reference
+    if (ref === '#') {
+        return ctx.rootSchema;
+    }
+    // Parse JSON Pointer path
+    const path = ref.slice(1); // Remove leading #
+    if (!path.startsWith('/')) {
+        return undefined;
+    }
+    const segments = path
+        .split('/')
+        .slice(1) // Remove empty first segment
+        .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+    // Navigate to the referenced schema
+    let current = ctx.rootSchema;
+    for (const segment of segments) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    // Cache the resolved schema
+    if (current && typeof current === 'object') {
+        const resolved = current;
+        ctx.definitions.set(ref, resolved);
+        return resolved;
+    }
+    return undefined;
+}
+
+/**
+ * Validates a value against a JSON Schema.
+ *
+ * @param instance - The value to validate
+ * @param schema - The JSON Schema to validate against
+ * @param options - Validation options
+ * @returns Validation result with valid flag and any errors
+ *
+ * @example
+ * ```typescript
+ * const schema = { type: 'string', minLength: 1 }
+ * const result = validate('hello', schema)
+ * console.log(result.valid) // true
+ * ```
+ */
+function validate(instance, schema, options) {
+    // Resolve safePatterns option to a checker function
+    let patternSafetyChecker;
+    const ctx = createValidationContext(schema, validateSchema, true, false, patternSafetyChecker);
+    const valid = validateSchema(instance, schema, ctx);
+    return {
+        valid,
+        errors: ctx.errors,
+    };
+}
+/**
+ * Internal recursive validation function.
+ *
+ * @param instance - Value being validated
+ * @param schema - Schema to validate against
+ * @param ctx - Validation context
+ * @returns true if validation passes, false otherwise
+ */
+function validateSchema(instance, schema, ctx) {
+    // Handle $ref
+    if (schema.$ref) {
+        const resolved = resolveRef(schema.$ref, ctx);
+        /* istanbul ignore if -- $ref resolution failures are tested in resolve-ref.spec.ts */
+        if (!resolved) {
+            // Could not resolve reference - treat as valid
+            return true;
+        }
+        return validateSchema(instance, resolved, ctx);
+    }
+    let valid = true;
+    // Type validation
+    if (!validateType(instance, schema, ctx)) {
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    // Enum validation
+    if (!validateEnum(instance, schema, ctx)) {
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    // String-specific validations
+    if (typeof instance === 'string') {
+        if (!validateStringBounds(instance, schema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        if (!validateFormat(instance, schema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    // Number-specific validations
+    if (typeof instance === 'number') {
+        if (!validateNumberBounds(instance, schema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    // Array-specific validations
+    if (isArray(instance)) {
+        if (!validateItems(instance, schema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        if (!validateArrayBounds(instance, schema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    // Object-specific validations
+    if (instance !== null && typeof instance === 'object' && !isArray(instance)) {
+        const obj = instance;
+        if (!validateProperties(obj, schema, ctx)) {
+            valid = false;
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        if (!validateRequired(obj, schema, ctx)) {
+            valid = false;
+            /* istanbul ignore if -- early exit tested elsewhere */
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        /* istanbul ignore next -- patternProperties validation */
+        if (!validatePatternProperties(obj, schema, ctx)) {
+            valid = false;
+            /* istanbul ignore next -- early exit tested elsewhere */
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        /* istanbul ignore next -- additionalProperties validation */
+        if (!validateAdditionalProperties(obj, schema, ctx)) {
+            valid = false;
+            /* istanbul ignore next -- early exit tested elsewhere */
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        /* istanbul ignore next -- objectBounds validation */
+        if (!validateObjectBounds(obj, schema, ctx)) {
+            valid = false;
+            /* istanbul ignore next -- early exit tested elsewhere */
+            if (!shouldContinue(ctx))
+                return false;
+        }
+        /* istanbul ignore next -- dependencies validation */
+        if (!validateDependencies(obj, schema, ctx)) {
+            valid = false;
+            /* istanbul ignore next -- early exit tested elsewhere */
+            if (!shouldContinue(ctx))
+                return false;
+        }
+    }
+    // Composition keywords
+    if (!validateAllOf(instance, schema, ctx)) {
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (!validateAnyOf(instance, schema, ctx)) {
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (!validateOneOf(instance, schema, ctx)) {
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    if (!validateNot(instance, schema, ctx)) {
+        valid = false;
+        if (!shouldContinue(ctx))
+            return false;
+    }
+    return valid;
+}
+
+/**
+ * Changelog JSON Schema
+ *
+ * JSON Schema definitions for changelog validation and schema compatibility checking.
+ * Uses `@hyperfrontend/json-utils` for validation.
+ */
+/**
+ * JSON Schema for a ChangelogLink.
+ */
+const changelogLinkSchema = {
+    type: 'object',
+    required: ['label', 'url'],
+    properties: {
+        label: { type: 'string' },
+        url: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for a CommitRef.
+ */
+const commitRefSchema = {
+    type: 'object',
+    required: ['hash', 'shortHash'],
+    properties: {
+        hash: { type: 'string', minLength: 7, maxLength: 40 },
+        shortHash: { type: 'string', minLength: 7, maxLength: 7 },
+        url: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for an IssueRef.
+ */
+const issueRefSchema = {
+    type: 'object',
+    required: ['number', 'type'],
+    properties: {
+        number: { type: 'integer', minimum: 1 },
+        type: { type: 'string', enum: ['issue', 'pull-request'] },
+        url: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for a ChangelogItem.
+ */
+const changelogItemSchema = {
+    type: 'object',
+    required: ['description', 'commits', 'references', 'breaking'],
+    properties: {
+        scope: { type: 'string' },
+        description: { type: 'string' },
+        breaking: { type: 'boolean' },
+        commits: {
+            type: 'array',
+            items: commitRefSchema,
+        },
+        references: {
+            type: 'array',
+            items: issueRefSchema,
+        },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for a ChangelogSection.
+ */
+const changelogSectionSchema = {
+    type: 'object',
+    required: ['type', 'heading', 'items'],
+    properties: {
+        type: {
+            type: 'string',
+            enum: [
+                'breaking',
+                'features',
+                'fixes',
+                'performance',
+                'documentation',
+                'deprecations',
+                'refactoring',
+                'tests',
+                'build',
+                'ci',
+                'chores',
+                'other',
+            ],
+        },
+        heading: { type: 'string' },
+        items: {
+            type: 'array',
+            items: changelogItemSchema,
+        },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for a ChangelogEntry.
+ */
+const changelogEntrySchema = {
+    type: 'object',
+    required: ['version', 'date', 'unreleased', 'sections'],
+    properties: {
+        version: { type: 'string' },
+        date: { type: ['string', 'null'] },
+        unreleased: { type: 'boolean' },
+        compareUrl: { type: 'string' },
+        sections: {
+            type: 'array',
+            items: changelogSectionSchema,
+        },
+        rawContent: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for ChangelogHeader.
+ */
+const changelogHeaderSchema = {
+    type: 'object',
+    required: ['title', 'description', 'links'],
+    properties: {
+        title: { type: 'string' },
+        description: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+        links: {
+            type: 'array',
+            items: changelogLinkSchema,
+        },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for ChangelogMetadata.
+ */
+const changelogMetadataSchema = {
+    type: 'object',
+    required: ['format', 'isConventional', 'warnings'],
+    properties: {
+        format: {
+            type: 'string',
+            enum: ['keep-a-changelog', 'conventional', 'custom', 'unknown'],
+        },
+        isConventional: { type: 'boolean' },
+        repositoryUrl: { type: 'string' },
+        packageName: { type: 'string' },
+        warnings: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+    },
+    additionalProperties: false,
+};
+/**
+ * JSON Schema for a complete Changelog document.
+ * Used for validation and format compatibility checking.
+ */
+const changelogSchema = {
+    type: 'object',
+    required: ['header', 'entries', 'metadata'],
+    properties: {
+        source: { type: 'string' },
+        header: changelogHeaderSchema,
+        entries: {
+            type: 'array',
+            items: changelogEntrySchema,
+        },
+        metadata: changelogMetadataSchema,
+    },
+    additionalProperties: false,
+};
+/**
+ * Validates a changelog object against the schema.
+ *
+ * @param changelog - The changelog object to validate
+ * @returns Validation result with any errors
+ *
+ * @example
+ * ```ts
+ * const result = validateChangelog(myChangelog)
+ * if (!result.valid) {
+ *   console.log('Validation errors:', result.errors)
+ * }
+ * ```
+ */
+function validateChangelog(changelog) {
+    return validate(changelog, changelogSchema);
+}
+/**
+ * Checks if two changelogs have compatible schemas.
+ * Used to detect format incompatibilities before merge/compare.
+ *
+ * @param source - The source changelog
+ * @param target - The target changelog
+ * @returns Compatibility result with any differences found
+ *
+ * @example
+ * ```ts
+ * const result = checkSchemaCompatibility(mainChangelog, branchChangelog)
+ * if (!result.compatible) {
+ *   console.log('Schema differences:', result.differences)
+ * }
+ * ```
+ */
+function checkSchemaCompatibility(source, target) {
+    const differences = [];
+    // Check format compatibility
+    if (source.metadata.format !== target.metadata.format) {
+        differences.push({
+            path: 'metadata.format',
+            type: 'type-mismatch',
+            sourceType: source.metadata.format,
+            targetType: target.metadata.format,
+        });
+    }
+    // Check header structure
+    if (source.header.title !== target.header.title) ;
+    // Check section types used
+    const sourceSectionTypes = createSet();
+    const targetSectionTypes = createSet();
+    for (const entry of source.entries) {
+        for (const section of entry.sections) {
+            sourceSectionTypes.add(section.type);
+        }
+    }
+    for (const entry of target.entries) {
+        for (const section of entry.sections) {
+            targetSectionTypes.add(section.type);
+        }
+    }
+    // Find section types in source but not in target
+    for (const type of sourceSectionTypes) {
+        if (!targetSectionTypes.has(type)) {
+            differences.push({
+                path: `sections[type=${type}]`,
+                type: 'missing-property',
+                sourceType: type,
+            });
+        }
+    }
+    // Find section types in target but not in source
+    for (const type of targetSectionTypes) {
+        if (!sourceSectionTypes.has(type)) {
+            differences.push({
+                path: `sections[type=${type}]`,
+                type: 'extra-property',
+                targetType: type,
+            });
+        }
+    }
+    return {
+        compatible: differences.length === 0,
+        differences,
+    };
+}
+
+exports.SECTION_HEADINGS = SECTION_HEADINGS;
+exports.SECTION_TYPE_MAP = SECTION_TYPE_MAP;
+exports.changelogSchema = changelogSchema;
+exports.checkSchemaCompatibility = checkSchemaCompatibility;
+exports.createChangelog = createChangelog;
+exports.createChangelogEntry = createChangelogEntry;
+exports.createChangelogItem = createChangelogItem;
+exports.createChangelogLink = createChangelogLink;
+exports.createChangelogSection = createChangelogSection;
+exports.createCommitRef = createCommitRef;
+exports.createEmptyChangelog = createEmptyChangelog;
+exports.createIssueRef = createIssueRef;
+exports.createUnreleasedEntry = createUnreleasedEntry;
+exports.getSectionType = getSectionType;
+exports.getShortHash = getShortHash;
+exports.validateChangelog = validateChangelog;
+//# sourceMappingURL=index.cjs.js.map