@hyperfrontend/immutable-api-utils 0.0.2 → 0.1.0

package/index.esm.js

@@ -1,7 +1,1140 @@
+/**
+ * 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.
  *
@@ -9,6 +1142,18 @@
  * - 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 = () => {
@@ -22,8 +1167,8 @@ const locked = () => {
             // 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,
@@ -33,7 +1178,7 @@ const locked = () => {
                 return this[BOUND];
             },
             set() {
-                throw new TypeError(`Cannot overwrite locked method ${String(key)}`);
+                throw createTypeError(`Cannot overwrite locked method ${String(key)}`);
             },
         };
     };
@@ -49,8 +1194,8 @@ const lockedPropertyDescriptors = (value, enumerable = false) => ({
 const lockedProps = (object, propertyValuePairs) => {
     const propertyMap = {};
     propertyValuePairs.forEach(([key, value]) => (propertyMap[key] = lockedPropertyDescriptors(value)));
-    Object.defineProperties(object, propertyMap);
+    defineProperties(object, propertyMap);
 };
 
-export { locked, lockedPropertyDescriptors, lockedProps };
+export { Array, Console, Date, Error, Function, JSON, Map, Messaging, Object$1 as Object, Promise$1 as Promise, Reflect, RegExp, Set, Symbol$1 as Symbol, Timers, WeakMap, WeakSet, locked, lockedPropertyDescriptors, lockedProps };
 //# sourceMappingURL=index.esm.js.map