@hyperfrontend/immutable-api-utils 0.0.2 → 0.1.1

package/bundle/index.iife.js

@@ -1,10 +1,1143 @@
 var HyperfrontendImmutableApiUtils = (function (exports) {
     'use strict';
 
+    /**
+     * 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;
+    const _freeze$f = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Determines whether the passed value is an Array.
+     */
+    const isArray = _Array.isArray;
+    /**
+     * (Safe copy) Creates an array from an array-like or iterable object.
+     */
+    const from = _Array.from;
+    /**
+     * (Safe copy) Creates a new Array instance from a variable number of arguments.
+     */
+    const of = _Array.of;
+    /**
+     * (Safe copy) Namespace object containing all Array static methods.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Array = _freeze$f({
+        isArray,
+        from,
+        of,
+    });
+
+    /**
+     * Safe copies of Console 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/console
+     */
+    // Capture references at module initialization time
+    const _console = globalThis.console;
+    const _freeze$e = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Outputs a message to the console.
+     */
+    const log = _console.log.bind(_console);
+    /**
+     * (Safe copy) Outputs a warning message to the console.
+     */
+    const warn = _console.warn.bind(_console);
+    /**
+     * (Safe copy) Outputs an error message to the console.
+     */
+    const error = _console.error.bind(_console);
+    /**
+     * (Safe copy) Outputs an informational message to the console.
+     */
+    const info = _console.info.bind(_console);
+    /**
+     * (Safe copy) Outputs a debug message to the console.
+     */
+    const debug = _console.debug.bind(_console);
+    /**
+     * (Safe copy) Outputs a stack trace to the console.
+     */
+    const trace = _console.trace.bind(_console);
+    /**
+     * (Safe copy) Displays an interactive listing of the properties of a specified object.
+     */
+    const dir = _console.dir.bind(_console);
+    /**
+     * (Safe copy) Displays tabular data as a table.
+     */
+    const table = _console.table.bind(_console);
+    /**
+     * (Safe copy) Writes an error message to the console if the assertion is false.
+     */
+    const assert = _console.assert.bind(_console);
+    /**
+     * (Safe copy) Clears the console.
+     */
+    const clear = _console.clear.bind(_console);
+    /**
+     * (Safe copy) Logs the number of times that this particular call to count() has been called.
+     */
+    const count = _console.count.bind(_console);
+    /**
+     * (Safe copy) Resets the counter used with console.count().
+     */
+    const countReset = _console.countReset.bind(_console);
+    /**
+     * (Safe copy) Creates a new inline group in the console.
+     */
+    const group = _console.group.bind(_console);
+    /**
+     * (Safe copy) Creates a new inline group in the console that is initially collapsed.
+     */
+    const groupCollapsed = _console.groupCollapsed.bind(_console);
+    /**
+     * (Safe copy) Exits the current inline group.
+     */
+    const groupEnd = _console.groupEnd.bind(_console);
+    /**
+     * (Safe copy) Starts a timer with a name specified as an input parameter.
+     */
+    const time = _console.time.bind(_console);
+    /**
+     * (Safe copy) Stops a timer that was previously started.
+     */
+    const timeEnd = _console.timeEnd.bind(_console);
+    /**
+     * (Safe copy) Logs the current value of a timer that was previously started.
+     */
+    const timeLog = _console.timeLog.bind(_console);
+    /**
+     * (Safe copy) Namespace object containing all Console methods.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Console = _freeze$e({
+        log,
+        warn,
+        error,
+        info,
+        debug,
+        trace,
+        dir,
+        table,
+        assert,
+        clear,
+        count,
+        countReset,
+        group,
+        groupCollapsed,
+        groupEnd,
+        time,
+        timeEnd,
+        timeLog,
+    });
+
+    /**
+     * 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$b = globalThis.Reflect;
+    const _freeze$d = globalThis.Object.freeze;
+    function createDate(...args) {
+        return _Reflect$b.construct(_Date, args);
+    }
+    /**
+     * (Safe copy) Returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+     */
+    const dateNow = _Date.now;
+    /**
+     * (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 copy) Namespace object containing Date factory and static methods.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Date = _freeze$d({
+        create: createDate,
+        now: dateNow,
+        parse: dateParse,
+        UTC: dateUTC,
+    });
+
+    /**
+     * 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 _TypeError = globalThis.TypeError;
+    const _RangeError = globalThis.RangeError;
+    const _ReferenceError = globalThis.ReferenceError;
+    const _SyntaxError = globalThis.SyntaxError;
+    const _URIError = globalThis.URIError;
+    const _EvalError = globalThis.EvalError;
+    const _AggregateError = globalThis.AggregateError;
+    const _Reflect$a = globalThis.Reflect;
+    const _freeze$c = globalThis.Object.freeze;
+    /**
+     * (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$a.construct(_Error, [message, options]);
+    /**
+     * (Safe copy) Creates a new TypeError using the captured TypeError constructor.
+     * Use this instead of `new TypeError()`.
+     *
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new TypeError instance.
+     */
+    const createTypeError = (message, options) => _Reflect$a.construct(_TypeError, [message, options]);
+    /**
+     * (Safe copy) Creates a new RangeError using the captured RangeError constructor.
+     * Use this instead of `new RangeError()`.
+     *
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new RangeError instance.
+     */
+    const createRangeError = (message, options) => _Reflect$a.construct(_RangeError, [message, options]);
+    /**
+     * (Safe copy) Creates a new ReferenceError using the captured ReferenceError constructor.
+     * Use this instead of `new ReferenceError()`.
+     *
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new ReferenceError instance.
+     */
+    const createReferenceError = (message, options) => _Reflect$a.construct(_ReferenceError, [message, options]);
+    /**
+     * (Safe copy) Creates a new SyntaxError using the captured SyntaxError constructor.
+     * Use this instead of `new SyntaxError()`.
+     *
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new SyntaxError instance.
+     */
+    const createSyntaxError = (message, options) => _Reflect$a.construct(_SyntaxError, [message, options]);
+    /**
+     * (Safe copy) Creates a new URIError using the captured URIError constructor.
+     * Use this instead of `new URIError()`.
+     *
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new URIError instance.
+     */
+    const createURIError = (message, options) => _Reflect$a.construct(_URIError, [message, options]);
+    /**
+     * (Safe copy) Creates a new EvalError using the captured EvalError constructor.
+     * Use this instead of `new EvalError()`.
+     *
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new EvalError instance.
+     */
+    const createEvalError = (message, options) => _Reflect$a.construct(_EvalError, [message, options]);
+    /**
+     * (Safe copy) Creates a new AggregateError using the captured AggregateError constructor.
+     * Use this instead of `new AggregateError()`.
+     *
+     * @param errors - An iterable of errors to aggregate.
+     * @param message - Optional error message.
+     * @param options - Optional error options.
+     * @returns A new AggregateError instance.
+     */
+    const createAggregateError = (errors, message, options) => _Reflect$a.construct(_AggregateError, [errors, message, options]);
+    /**
+     * (Safe copy) Namespace object containing Error factory functions.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Error = _freeze$c({
+        create: createError,
+        TypeError: createTypeError,
+        RangeError: createRangeError,
+        ReferenceError: createReferenceError,
+        SyntaxError: createSyntaxError,
+        URIError: createURIError,
+        EvalError: createEvalError,
+        AggregateError: createAggregateError,
+    });
+
+    /**
+     * Safe copies of Function built-in and utilities.
+     *
+     * 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/function
+     */
+    // Capture references at module initialization time
+    const _Function = globalThis.Function;
+    const _FunctionPrototype = _Function.prototype;
+    const _Reflect$9 = globalThis.Reflect;
+    const _freeze$b = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Creates a new Function using the captured Function constructor.
+     * Use this instead of `new Function()`.
+     *
+     * NOTE: Dynamic code generation via Function constructor should be avoided when possible
+     * due to security risks similar to eval().
+     *
+     * @param args - Function body and parameter strings.
+     * @returns A new Function.
+     */
+    const createFunction = (...args) => _Reflect$9.construct(_Function, args);
+    /**
+     * (Safe copy) Reference to the captured Function.prototype.
+     */
+    const functionPrototype = _FunctionPrototype;
+    /**
+     * (Safe copy) Reference to the captured Function.prototype.call.
+     */
+    const functionCall = _FunctionPrototype.call;
+    /**
+     * (Safe copy) Reference to the captured Function.prototype.apply.
+     */
+    const functionApply = _FunctionPrototype.apply;
+    /**
+     * (Safe copy) Reference to the captured Function.prototype.bind.
+     */
+    const functionBind = _FunctionPrototype.bind;
+    /**
+     * (Safe copy) Namespace object containing Function utilities.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Function = _freeze$b({
+        create: createFunction,
+        prototype: functionPrototype,
+        call: functionCall,
+        apply: functionApply,
+        bind: functionBind,
+    });
+
+    /**
+     * 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;
+    const _freeze$a = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Converts a JavaScript Object Notation (JSON) string into an object.
+     */
+    const parse = _JSON.parse;
+    /**
+     * (Safe copy) Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+     */
+    const stringify = _JSON.stringify;
+    /**
+     * (Safe copy) Namespace object containing all JSON methods.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const JSON = _freeze$a({
+        parse,
+        stringify,
+    });
+
+    /**
+     * 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$8 = globalThis.Reflect;
+    const _freeze$9 = globalThis.Object.freeze;
+    /**
+     * (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$8.construct(_Map, iterable ? [iterable] : []);
+    /**
+     * (Safe copy) Groups elements by key using the captured Map.groupBy if available.
+     * Note: Available only in ES2024+ environments.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mapGroupBy = _Map.groupBy;
+    /**
+     * (Safe copy) Namespace object containing Map factory.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Map = _freeze$9({
+        create: createMap,
+        groupBy: mapGroupBy,
+    });
+
+    /**
+     * Safe copies of Messaging/Communication built-in functions and constructors.
+     *
+     * These references are captured at module initialization time to protect against
+     * prototype pollution attacks. Import only what you need for tree-shaking.
+     *
+     * Note: `postMessage` is a method on specific objects (Window, Worker, MessagePort)
+     * rather than a global. This module provides factory functions for MessageChannel
+     * and BroadcastChannel, whose instances have safe postMessage methods.
+     *
+     * @module @hyperfrontend/immutable-api-utils/built-in-copy/messaging
+     */
+    // Capture references at module initialization time
+    const _Reflect$7 = globalThis.Reflect;
+    const _freeze$8 = globalThis.Object.freeze;
+    const _structuredClone = typeof globalThis.structuredClone === 'function' ? globalThis.structuredClone : undefined;
+    const _MessageChannel = typeof globalThis.MessageChannel === 'function' ? globalThis.MessageChannel : undefined;
+    const _BroadcastChannel = typeof globalThis.BroadcastChannel === 'function' ? globalThis.BroadcastChannel : undefined;
+    /**
+     * (Safe copy) Creates a deep clone of a value using the structured clone algorithm.
+     * Available in modern browsers and Node.js 17+.
+     *
+     * @param value - The value to clone.
+     * @param options - Optional transfer or serialization options.
+     * @returns A deep clone of the value.
+     */
+    const structuredClone = _structuredClone
+        ? (value, options) => _structuredClone(value, options)
+        : undefined;
+    /**
+     * (Safe copy) Creates a new MessageChannel using the captured constructor.
+     * MessageChannel provides two ports for bidirectional communication.
+     *
+     * @returns A new MessageChannel instance or undefined if not available.
+     */
+    const createMessageChannel = _MessageChannel
+        ? () => _Reflect$7.construct(_MessageChannel, [])
+        : undefined;
+    /**
+     * (Safe copy) Creates a new BroadcastChannel using the captured constructor.
+     * BroadcastChannel enables communication between browsing contexts with the same origin.
+     *
+     * @param name - Identifier for the broadcast channel that other contexts use to subscribe.
+     * @returns A new BroadcastChannel instance or undefined if not available.
+     */
+    const createBroadcastChannel = _BroadcastChannel
+        ? (name) => _Reflect$7.construct(_BroadcastChannel, [name])
+        : undefined;
+    /**
+     * (Safe copy) Posts a message to a Window object using captured postMessage.
+     * This is a helper that wraps Window.postMessage for safe messaging.
+     *
+     * @param target - Destination window, iframe, or popup context.
+     * @param message - The data payload to send, must be structured-cloneable.
+     * @param options - Target origin and optional transferables.
+     */
+    const postMessageToWindow = (target, message, options) => {
+        target.postMessage(message, options.targetOrigin, options.transfer);
+    };
+    /**
+     * (Safe copy) Posts a message to a Worker using captured postMessage.
+     *
+     * @param target - Web Worker or service worker instance.
+     * @param message - The data payload to send, must be structured-cloneable.
+     * @param transfer - Optional array of Transferable objects.
+     */
+    const postMessageToWorker = (target, message, transfer) => {
+        if (transfer) {
+            target.postMessage(message, transfer);
+        }
+        else {
+            target.postMessage(message);
+        }
+    };
+    /**
+     * (Safe copy) Posts a message to a MessagePort.
+     *
+     * @param port - One end of a two-way communication channel.
+     * @param message - The data payload to send, must be structured-cloneable.
+     * @param transfer - Optional array of Transferable objects.
+     */
+    const postMessageToPort = (port, message, transfer) => {
+        if (transfer) {
+            port.postMessage(message, transfer);
+        }
+        else {
+            port.postMessage(message);
+        }
+    };
+    /**
+     * (Safe copy) Posts a message to a BroadcastChannel.
+     *
+     * @param channel - Named broadcast channel for same-origin contexts.
+     * @param message - The data payload to send, must be structured-cloneable.
+     */
+    const postMessageToBroadcast = (channel, message) => {
+        channel.postMessage(message);
+    };
+    /**
+     * (Safe copy) Namespace object containing all Messaging functions.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Messaging = _freeze$8({
+        structuredClone,
+        createMessageChannel,
+        createBroadcastChannel,
+        postMessageToWindow,
+        postMessageToWorker,
+        postMessageToPort,
+        postMessageToBroadcast,
+    });
+
+    /**
+     * 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$6 = globalThis.Reflect;
+    const _ObjectPrototype = _Object.prototype;
+    const _hasOwnProperty = _ObjectPrototype.hasOwnProperty;
+    /**
+     * (Safe copy) Prevents modification of existing property attributes and values,
+     * and prevents the addition of new properties.
+     */
+    const freeze = _Object.freeze;
+    /**
+     * (Safe copy) Creates an object that has the specified prototype or that has null prototype.
+     */
+    const create = _Object.create;
+    /**
+     * (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) Returns an array of values of the enumerable own properties of an object.
+     */
+    const values = _Object.values;
+    /**
+     * (Safe copy) Returns an object from an iterable of key-value pairs.
+     */
+    const fromEntries = _Object.fromEntries;
+    /**
+     * (Safe copy) Copy the values of all enumerable own properties from one or more source objects
+     * to a target object. Returns the target object.
+     */
+    const assign = _Object.assign;
+    /**
+     * (Safe copy) Adds a property to an object, or modifies attributes of an existing property.
+     */
+    const defineProperty$1 = _Object.defineProperty;
+    /**
+     * (Safe copy) Adds one or more properties to an object, and/or modifies attributes of existing properties.
+     */
+    const defineProperties = _Object.defineProperties;
+    /**
+     * (Safe copy) Determines whether an object has a property with the specified name.
+     */
+    const objectHasOwn = _Object.hasOwn;
+    /**
+     * (Safe copy) Sets the prototype of a specified object o to object proto or null.
+     */
+    const setPrototypeOf$1 = _Object.setPrototypeOf;
+    /**
+     * (Safe copy) Returns the prototype of an object.
+     */
+    const getPrototypeOf$1 = _Object.getPrototypeOf;
+    /**
+     * (Safe copy) Prevents the addition of new properties to an object.
+     */
+    const seal = _Object.seal;
+    /**
+     * (Safe copy) Returns true if existing property attributes and values cannot be modified
+     * in an object, and new properties cannot be added to the object.
+     */
+    const isFrozen = _Object.isFrozen;
+    /**
+     * (Safe copy) Returns true if existing property attributes cannot be modified in an object
+     * and new properties cannot be added to the object.
+     */
+    const isSealed = _Object.isSealed;
+    /**
+     * (Safe copy) Returns a value that indicates whether new properties can be added to an object.
+     */
+    const isExtensible$1 = _Object.isExtensible;
+    /**
+     * (Safe copy) Prevents the addition of new properties to an object.
+     */
+    const preventExtensions$1 = _Object.preventExtensions;
+    /**
+     * (Safe copy) Gets the own property descriptor of the specified object.
+     */
+    const getOwnPropertyDescriptor$1 = _Object.getOwnPropertyDescriptor;
+    /**
+     * (Safe copy) Returns the names of the own properties of an object.
+     */
+    const getOwnPropertyNames = _Object.getOwnPropertyNames;
+    /**
+     * (Safe copy) Returns an array of all symbol properties found directly on object o.
+     */
+    const getOwnPropertySymbols = _Object.getOwnPropertySymbols;
+    /**
+     * (Safe copy) Gets the own property descriptors of the specified object.
+     */
+    const getOwnPropertyDescriptors = _Object.getOwnPropertyDescriptors;
+    /**
+     * (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$6.apply(_hasOwnProperty, obj, [key]);
+    /**
+     * (Safe copy) Namespace object containing all Object static methods.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Object$1 = _Object.freeze({
+        freeze,
+        create,
+        keys,
+        entries,
+        values,
+        fromEntries,
+        assign,
+        defineProperty: defineProperty$1,
+        defineProperties,
+        hasOwn: objectHasOwn,
+        setPrototypeOf: setPrototypeOf$1,
+        getPrototypeOf: getPrototypeOf$1,
+        seal,
+        isFrozen,
+        isSealed,
+        isExtensible: isExtensible$1,
+        preventExtensions: preventExtensions$1,
+        getOwnPropertyDescriptor: getOwnPropertyDescriptor$1,
+        getOwnPropertyNames,
+        getOwnPropertySymbols,
+        getOwnPropertyDescriptors,
+    });
+
+    /**
+     * Safe copies of Promise built-in methods 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/promise
+     */
+    // Capture references at module initialization time
+    const _Promise = globalThis.Promise;
+    const _Reflect$5 = globalThis.Reflect;
+    const _freeze$7 = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Creates a new Promise using the captured Promise constructor.
+     * Use this instead of `new Promise()`.
+     *
+     * @param executor - The executor function.
+     * @returns A new Promise instance.
+     */
+    const createPromise = (executor) => _Reflect$5.construct(_Promise, [executor]);
+    /**
+     * (Safe copy) Returns a Promise that resolves with the given value.
+     */
+    const promiseResolve = _Promise.resolve.bind(_Promise);
+    /**
+     * (Safe copy) Returns a Promise that rejects with the given reason.
+     */
+    const promiseReject = _Promise.reject.bind(_Promise);
+    /**
+     * (Safe copy) Returns a Promise that resolves when all promises resolve.
+     */
+    const promiseAll = _Promise.all.bind(_Promise);
+    /**
+     * (Safe copy) Returns a Promise that resolves/rejects with the first settled promise.
+     */
+    const promiseRace = _Promise.race.bind(_Promise);
+    /**
+     * (Safe copy) Returns a Promise that resolves when all promises settle.
+     */
+    const promiseAllSettled = _Promise.allSettled.bind(_Promise);
+    /**
+     * (Safe copy) Returns a Promise that resolves with the first fulfilled promise.
+     */
+    const promiseAny = _Promise.any.bind(_Promise);
+    /**
+     * (Safe copy) Creates a Promise along with its resolve and reject functions.
+     * Note: Available only in ES2024+ environments.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const promiseWithResolvers = _Promise.withResolvers?.bind(_Promise);
+    /**
+     * (Safe copy) Namespace object containing all Promise factory functions.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Promise$1 = _freeze$7({
+        create: createPromise,
+        resolve: promiseResolve,
+        reject: promiseReject,
+        all: promiseAll,
+        race: promiseRace,
+        allSettled: promiseAllSettled,
+        any: promiseAny,
+        withResolvers: promiseWithResolvers,
+    });
+
+    /**
+     * Safe copies of Reflect 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/reflect
+     */
+    // Capture references at module initialization time
+    const _Reflect$4 = globalThis.Reflect;
+    const _freeze$6 = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Calls the function with the specified object as the this value
+     * and the elements of specified array as the arguments.
+     */
+    const apply = _Reflect$4.apply;
+    /**
+     * (Safe copy) Constructs the target with the elements of specified array as the arguments.
+     */
+    const construct = _Reflect$4.construct;
+    /**
+     * (Safe copy) Gets the property of target, equivalent to target[propertyKey].
+     */
+    const get = _Reflect$4.get;
+    /**
+     * (Safe copy) Sets the property of target, equivalent to target[propertyKey] = value.
+     */
+    const set = _Reflect$4.set;
+    /**
+     * (Safe copy) Determines whether an object has a property with the specified name.
+     */
+    const has = _Reflect$4.has;
+    /**
+     * (Safe copy) Returns an array of the target object's own property keys.
+     */
+    const ownKeys = _Reflect$4.ownKeys;
+    /**
+     * (Safe copy) Adds or modifies a property on an object.
+     */
+    const defineProperty = _Reflect$4.defineProperty;
+    /**
+     * (Safe copy) Deletes a property from an object.
+     */
+    const deleteProperty = _Reflect$4.deleteProperty;
+    /**
+     * (Safe copy) Gets the property descriptor of the specified property.
+     */
+    const getOwnPropertyDescriptor = _Reflect$4.getOwnPropertyDescriptor;
+    /**
+     * (Safe copy) Returns the prototype of the specified object.
+     */
+    const getPrototypeOf = _Reflect$4.getPrototypeOf;
+    /**
+     * (Safe copy) Sets the prototype of the specified object.
+     */
+    const setPrototypeOf = _Reflect$4.setPrototypeOf;
+    /**
+     * (Safe copy) Returns a boolean indicating whether the object is extensible.
+     */
+    const isExtensible = _Reflect$4.isExtensible;
+    /**
+     * (Safe copy) Prevents new properties from being added to the object.
+     */
+    const preventExtensions = _Reflect$4.preventExtensions;
+    /**
+     * (Safe copy) Namespace object containing all Reflect methods.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Reflect = _freeze$6({
+        apply,
+        construct,
+        get,
+        set,
+        has,
+        ownKeys,
+        defineProperty,
+        deleteProperty,
+        getOwnPropertyDescriptor,
+        getPrototypeOf,
+        setPrototypeOf,
+        isExtensible,
+        preventExtensions,
+    });
+
+    /**
+     * 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$3 = globalThis.Reflect;
+    const _freeze$5 = globalThis.Object.freeze;
+    /**
+     * (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$3.construct(_RegExp, [pattern, flags]);
+    /**
+     * (Safe copy) Namespace object containing RegExp factory.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const RegExp = _freeze$5({
+        create: createRegExp,
+    });
+
+    /**
+     * 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$2 = globalThis.Reflect;
+    const _freeze$4 = globalThis.Object.freeze;
+    /**
+     * (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$2.construct(_Set, iterable ? [iterable] : []);
+    /**
+     * (Safe copy) Namespace object containing Set factory.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Set = _freeze$4({
+        create: createSet,
+    });
+
+    /**
+     * Safe copies of Symbol built-in and well-known symbols.
+     *
+     * 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/symbol
+     */
+    // Capture references at module initialization time
+    const _Symbol = globalThis.Symbol;
+    const _freeze$3 = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Creates a new Symbol with optional description.
+     * Use this instead of `Symbol()`.
+     *
+     * @param description - Optional description for the symbol.
+     * @returns A new Symbol.
+     */
+    const createSymbol = (description) => _Symbol(description);
+    /**
+     * (Safe copy) Returns a Symbol object from the global symbol registry.
+     */
+    const symbolFor = _Symbol.for;
+    /**
+     * (Safe copy) Returns a key from the global symbol registry.
+     */
+    const symbolKeyFor = _Symbol.keyFor;
+    // Well-known symbols (captured)
+    /**
+     * (Safe copy) A method that returns the default iterator for an object.
+     */
+    const symbolIterator = _Symbol.iterator;
+    /**
+     * (Safe copy) A method that returns the default async iterator for an object.
+     */
+    const symbolAsyncIterator = _Symbol.asyncIterator;
+    /**
+     * (Safe copy) A method that converts an object to a primitive value.
+     */
+    const symbolToStringTag = _Symbol.toStringTag;
+    /**
+     * (Safe copy) A method that determines if a constructor object recognizes an object as its instance.
+     */
+    const symbolHasInstance = _Symbol.hasInstance;
+    /**
+     * (Safe copy) A Boolean value indicating if an object should be flattened to its array elements.
+     */
+    const symbolIsConcatSpreadable = _Symbol.isConcatSpreadable;
+    /**
+     * (Safe copy) A method that matches against a string.
+     */
+    const symbolMatch = _Symbol.match;
+    /**
+     * (Safe copy) A method that returns an index within a string that matches the regular expression.
+     */
+    const symbolMatchAll = _Symbol.matchAll;
+    /**
+     * (Safe copy) A method that replaces matched substrings of a string.
+     */
+    const symbolReplace = _Symbol.replace;
+    /**
+     * (Safe copy) A method that returns the index within a string that matches the regular expression.
+     */
+    const symbolSearch = _Symbol.search;
+    /**
+     * (Safe copy) A method that splits a string at the indices that match a regular expression.
+     */
+    const symbolSplit = _Symbol.split;
+    /**
+     * (Safe copy) A function valued property that is the constructor function that is used to create derived objects.
+     */
+    const symbolSpecies = _Symbol.species;
+    /**
+     * (Safe copy) A method that converts an object to a primitive value.
+     */
+    const symbolToPrimitive = _Symbol.toPrimitive;
+    /**
+     * (Safe copy) An Object whose own property names are property names that are excluded from the with environment bindings.
+     */
+    const symbolUnscopables = _Symbol.unscopables;
+    /**
+     * (Safe copy) Namespace object containing Symbol utilities and well-known symbols.
+     * Note: Importing this imports all symbols in this namespace (no tree-shaking).
+     */
+    const Symbol$1 = _freeze$3({
+        create: createSymbol,
+        for: symbolFor,
+        keyFor: symbolKeyFor,
+        iterator: symbolIterator,
+        asyncIterator: symbolAsyncIterator,
+        toStringTag: symbolToStringTag,
+        hasInstance: symbolHasInstance,
+        isConcatSpreadable: symbolIsConcatSpreadable,
+        match: symbolMatch,
+        matchAll: symbolMatchAll,
+        replace: symbolReplace,
+        search: symbolSearch,
+        split: symbolSplit,
+        species: symbolSpecies,
+        toPrimitive: symbolToPrimitive,
+        unscopables: symbolUnscopables,
+    });
+
+    /**
+     * Safe copies of Timer/Scheduling built-in functions.
+     *
+     * 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/timers
+     */
+    // Capture references at module initialization time
+    const _setTimeout = globalThis.setTimeout;
+    const _setInterval = globalThis.setInterval;
+    const _clearTimeout = globalThis.clearTimeout;
+    const _clearInterval = globalThis.clearInterval;
+    const _queueMicrotask = globalThis.queueMicrotask;
+    const _requestAnimationFrame = typeof globalThis.requestAnimationFrame === 'function' ? globalThis.requestAnimationFrame : undefined;
+    const _cancelAnimationFrame = typeof globalThis.cancelAnimationFrame === 'function' ? globalThis.cancelAnimationFrame : undefined;
+    const _freeze$2 = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Sets a timer which executes a function once the timer expires.
+     *
+     * @param callback - Function to call when the timer elapses.
+     * @param delay - Time in milliseconds before executing.
+     * @param args - Additional arguments to pass to the callback.
+     * @returns A numeric ID for the timer.
+     */
+    const setTimeout = (callback, delay, ...args) => _setTimeout(callback, delay, ...args);
+    /**
+     * (Safe copy) Repeatedly calls a function with a fixed time delay between each call.
+     *
+     * @param callback - Function to call at each interval.
+     * @param delay - Time in milliseconds between calls.
+     * @param args - Additional arguments to pass to the callback.
+     * @returns A numeric ID for the interval.
+     */
+    const setInterval = (callback, delay, ...args) => _setInterval(callback, delay, ...args);
+    /**
+     * (Safe copy) Cancels a timeout previously established by setTimeout.
+     *
+     * @param id - The identifier of the timeout to cancel.
+     */
+    const clearTimeout = (id) => {
+        _clearTimeout(id);
+    };
+    /**
+     * (Safe copy) Cancels a timed, repeating action previously established by setInterval.
+     *
+     * @param id - The identifier of the interval to cancel.
+     */
+    const clearInterval = (id) => {
+        _clearInterval(id);
+    };
+    /**
+     * (Safe copy) Queues a microtask to be executed before control returns to the event loop.
+     *
+     * @param callback - Function to execute.
+     */
+    const queueMicrotask = (callback) => {
+        _queueMicrotask(callback);
+    };
+    /**
+     * (Safe copy) Requests the browser to call a function before the next repaint.
+     * Available only in browser environments.
+     *
+     * @param callback - Function to call before repaint.
+     * @returns A request ID or undefined if not available.
+     */
+    const requestAnimationFrame = _requestAnimationFrame
+        ? (callback) => _requestAnimationFrame(callback)
+        : undefined;
+    /**
+     * (Safe copy) Cancels an animation frame request previously scheduled.
+     * Available only in browser environments.
+     *
+     * @param handle - The ID value returned by requestAnimationFrame.
+     */
+    const cancelAnimationFrame = _cancelAnimationFrame
+        ? (handle) => {
+            _cancelAnimationFrame(handle);
+        }
+        : undefined;
+    /**
+     * (Safe copy) Namespace object containing all Timer/Scheduling functions.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const Timers = _freeze$2({
+        setTimeout,
+        setInterval,
+        clearTimeout,
+        clearInterval,
+        queueMicrotask,
+        requestAnimationFrame,
+        cancelAnimationFrame,
+    });
+
+    /**
+     * Safe copies of WeakMap 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/weak-map
+     */
+    // Capture references at module initialization time
+    const _WeakMap = globalThis.WeakMap;
+    const _Reflect$1 = globalThis.Reflect;
+    const _freeze$1 = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Creates a new WeakMap using the captured WeakMap constructor.
+     * Use this instead of `new WeakMap()`.
+     *
+     * @param iterable - Optional iterable of key-value pairs.
+     * @returns A new WeakMap instance.
+     */
+    const createWeakMap = (iterable) => _Reflect$1.construct(_WeakMap, iterable ? [iterable] : []);
+    /**
+     * (Safe copy) Namespace object containing WeakMap factory.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const WeakMap = _freeze$1({
+        create: createWeakMap,
+    });
+
+    /**
+     * Safe copies of WeakSet 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/weak-set
+     */
+    // Capture references at module initialization time
+    const _WeakSet = globalThis.WeakSet;
+    const _Reflect = globalThis.Reflect;
+    const _freeze = globalThis.Object.freeze;
+    /**
+     * (Safe copy) Creates a new WeakSet using the captured WeakSet constructor.
+     * Use this instead of `new WeakSet()`.
+     *
+     * @param iterable - Optional iterable of values.
+     * @returns A new WeakSet instance.
+     */
+    const createWeakSet = (iterable) => _Reflect.construct(_WeakSet, iterable ? [iterable] : []);
+    /**
+     * (Safe copy) Namespace object containing WeakSet factory.
+     * Note: Importing this imports all methods in this namespace (no tree-shaking).
+     */
+    const WeakSet = _freeze({
+        create: createWeakSet,
+    });
+
     /**
      * Creates a decorator that locks a method to prevent overwriting and ensure correct `this` binding.
      *
-     * @locked
      * Ensures a classic prototype method cannot be overwritten and is
      * always called with the correct `this` instance without needing arrow functions.
      *
@@ -12,6 +1145,18 @@ var HyperfrontendImmutableApiUtils = (function (exports) {
      * - Any attempt to assign to the method throws an error.
      * - It does not support class fields / arrow functions.
      *
+     * @example
+     * ```ts
+     * class Counter {
+     *   private count = 0
+     *
+     *   \@locked()
+     *   increment() {
+     *     return ++this.count
+     *   }
+     * }
+     * ```
+     *
      * @returns A method decorator that locks the method
      */
     const locked = () => {
@@ -25,8 +1170,8 @@ var HyperfrontendImmutableApiUtils = (function (exports) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 get() {
                     // cache a bound function per instance
-                    if (!Object.prototype.hasOwnProperty.call(this, BOUND)) {
-                        Object.defineProperty(this, BOUND, {
+                    if (!hasOwn(this, BOUND)) {
+                        defineProperty$1(this, BOUND, {
                             value: original.bind(this),
                             writable: false,
                             configurable: false,
@@ -36,7 +1181,7 @@ var HyperfrontendImmutableApiUtils = (function (exports) {
                     return this[BOUND];
                 },
                 set() {
-                    throw new TypeError(`Cannot overwrite locked method ${String(key)}`);
+                    throw createTypeError(`Cannot overwrite locked method ${String(key)}`);
                 },
             };
         };
@@ -52,9 +1197,26 @@ var HyperfrontendImmutableApiUtils = (function (exports) {
     const lockedProps = (object, propertyValuePairs) => {
         const propertyMap = {};
         propertyValuePairs.forEach(([key, value]) => (propertyMap[key] = lockedPropertyDescriptors(value)));
-        Object.defineProperties(object, propertyMap);
+        defineProperties(object, propertyMap);
     };
 
+    exports.Array = Array;
+    exports.Console = Console;
+    exports.Date = Date;
+    exports.Error = Error;
+    exports.Function = Function;
+    exports.JSON = JSON;
+    exports.Map = Map;
+    exports.Messaging = Messaging;
+    exports.Object = Object$1;
+    exports.Promise = Promise$1;
+    exports.Reflect = Reflect;
+    exports.RegExp = RegExp;
+    exports.Set = Set;
+    exports.Symbol = Symbol$1;
+    exports.Timers = Timers;
+    exports.WeakMap = WeakMap;
+    exports.WeakSet = WeakSet;
     exports.locked = locked;
     exports.lockedPropertyDescriptors = lockedPropertyDescriptors;
     exports.lockedProps = lockedProps;