@hyperfrontend/list-utils 0.0.4 → 0.1.0

package/CHANGELOG.md

@@ -1,16 +1,34 @@
 # Changelog
 
-This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
+All notable changes to this project will be documented in this file.
 
-## [0.0.4](https://github.com/AndrewRedican/hyperfrontend/compare/lib-list-utils@0.0.3...lib-list-utils@0.0.4) (2026-03-08)
+## [0.1.0](https://github.com/AndrewRedican/hyperfrontend/compare/5f116abb8ba6355dfb283fa03b7481e5eb029480...cc16961a470190848f71a7cce41f7377bc4511a4) - 2026-08-25
 
-## [0.0.3](https://github.com/AndrewRedican/hyperfrontend/compare/lib-list-utils@0.0.2...lib-list-utils@0.0.3) (2026-03-02)
+### Breaking Changes
 
+- **BREAKING** type fifo pull as T | undefined, reword throws
 
 ### Bug Fixes
 
-* **lib-list-utils:** correct package exports ([5966537](https://github.com/AndrewRedican/hyperfrontend/commit/5966537bda3addd6d3bc22bb7b2e9a5cfef7c247))
+- **BREAKING** type fifo pull as T | undefined, reword throws
 
-## [0.0.2](https://github.com/AndrewRedican/hyperfrontend/compare/lib-list-utils@0.0.1...lib-list-utils@0.0.2) (2026-02-26)
+## [0.0.5](https://github.com/AndrewRedican/hyperfrontend/compare/c8db08be8b183addd26caf81fdd17fb3693f296f...466c0388c4cd516b9c704214140b4df1004098e6) - 2026-06-23
+
+### Other
+
+- **@hyperfrontend/workspace:** remove lib-builder and tool-package as implicit dependencies for all lib projects
+
+## [0.0.4](https://github.com/AndrewRedican/hyperfrontend/compare/lib-list-utils@0.0.3...lib-list-utils@0.0.4) - 2026-03-08
+
+
+## [0.0.3](https://github.com/AndrewRedican/hyperfrontend/compare/lib-list-utils@0.0.2...lib-list-utils@0.0.3) - 2026-03-02
+
+### Bug Fixes
+
+- **lib-list-utils:** correct package exports ([5966537](https://github.com/AndrewRedican/hyperfrontend/commit/5966537bda3addd6d3bc22bb7b2e9a5cfef7c247))
+
+## [0.0.2](https://github.com/AndrewRedican/hyperfrontend/compare/lib-list-utils@0.0.1...lib-list-utils@0.0.2) - 2026-02-26
+
+
+## 0.0.1 - 2026-02-15
 
-## 0.0.1 (2026-02-15)

package/README.md

@@ -35,6 +35,9 @@
 
 Purpose-built collection utilities for queue management, filtering, and iteration patterns.
 
+• 👉 See [**documentation**](https://www.hyperfrontend.dev/docs/libraries/utils/list/)
+• 👉 See [**guides & tutorials**](https://www.hyperfrontend.dev/docs/guides/?package=%40hyperfrontend%2Flist-utils)
+
 ## What is @hyperfrontend/list-utils?
 
 @hyperfrontend/list-utils provides specialized collection utilities focused on common programming patterns that native JavaScript arrays don't handle elegantly. Rather than replicating lodash, this library targets specific use cases: FIFO/LIFO queue management with object reference tracking, cyclical value iteration, and string array sanitization.
@@ -58,11 +61,11 @@ Queue implementations return frozen objects to prevent external mutation while u
 
 ### Prevents Queue Bugs in Event-Driven Systems
 
-Native arrays don't enforce uniqueness, making it easy to accidentally register the same event handler, task, or subscription multiple times. FIFO/LIFO lists automatically reject duplicates based on reference equality, eliminating a common source of memory leaks and duplicate processing in event loops, job queues, and observer patterns.
+Native arrays don't enforce uniqueness, making it easy to accidentally register the same event handler, task, or subscription multiple times. Both list kinds reject duplicates based on reference equality, eliminating a common source of memory leaks and duplicate processing in event loops, job queues, and observer patterns. A FIFO list throws on a duplicate push; a LIFO list ignores it.
 
 ### Simplifies Round-Robin and Cyclical Patterns
 
-The value picker solves the boilerplate problem of cycling through options (load balancer endpoints, color schemes, retry strategies). No manual index tracking or modulo math—just call `next()`. Particularly useful for testing scenarios where you need predictable value rotation.
+The value picker solves the boilerplate problem of cycling through options (load balancer endpoints, color schemes, retry strategies). No manual index tracking or modulo math, just call `next()`. Particularly useful for testing scenarios where you need predictable value rotation.
 
 ### Type-Safe String Sanitization
 
@@ -87,7 +90,7 @@ import { createFifoList, createValuePicker, nonEmptyStrings, uniqueStrings } fro
 const taskQueue = createFifoList<{ id: string; execute: () => void }>()
 taskQueue.push({ id: 'task1', execute: () => console.log('Task 1') })
 taskQueue.push({ id: 'task2', execute: () => console.log('Task 2') })
-const nextTask = taskQueue.pull() // Gets task1 (first in)
+const nextTask = taskQueue.pull() // Gets task1 (first in), or undefined once the queue is drained
 
 // Round-robin value picker
 const colorPicker = createValuePicker(['red', 'blue', 'green'])
@@ -166,4 +169,4 @@ This library is part of the [hyperfrontend](https://github.com/AndrewRedican/hyp
 
 ## License
 
-MIT
+[MIT](https://github.com/AndrewRedican/hyperfrontend/blob/main/LICENSE.md)

package/SECURITY.md

@@ -1,5 +1,28 @@
 # Security Policy
 
+## The Security Model
+
+Before reporting or reviewing, read the model this project is built on:
+**[Security Model](https://www.hyperfrontend.dev/docs/core-concepts/security)**. It is the canonical
+statement of what hyperfrontend defends against and what it does not, and it is the reference every
+other security claim in these docs points back to. In short:
+
+- **The named adversary is co-resident script**: an analytics snippet, tag manager, compromised
+  dependency, or unknown page that embeds a feature URL. A host that deliberately installs a feature
+  is trusting it, the way it trusts any dependency; the controls exist to bound a trusted
+  feature's bad day, not to treat its authors as hostile.
+- **Origin checks authenticate rooms, not speakers.** Once arbitrary script runs inside a page, no
+  message check distinguishes it from the application. Threats inside a page need Content Security
+  Policy, Trusted Types, dependency provenance, and server-side authorisation. That is a different
+  treatment, deliberately outside this model.
+- **Three parties carry the security of an integration.** The browser enforces document isolation
+  and the frame's capability attributes; the protocol enforces the relationship (pinned
+  counterparts, gated handshake, validated payloads, versioned contracts, an optional encrypted
+  envelope); and **you** decide authorisation: `frame-ancestors`, backend checks, HTTPS, the
+  envelope you choose, and the containment posture you set.
+
+A vulnerability report is most useful when it names which of those three the issue defeats.
+
 ## Reporting a Vulnerability
 
 We take the security of hyperfrontend seriously. If you discover a security vulnerability, please help us protect our users by following responsible disclosure practices.
@@ -58,14 +81,30 @@ Thank you for helping keep hyperfrontend and its users safe!
 
 ## Security Best Practices
 
-When using hyperfrontend in your applications:
-
-1. **Keep Dependencies Updated**: Regularly update to the latest version to receive security patches
-2. **Content Security Policy**: Implement appropriate CSP headers when embedding features
-3. **Input Validation**: Validate and sanitize all data passed between features
-4. **Origin Verification**: Always verify the origin of messages in cross-frame communication
-5. **Authentication**: Implement proper authentication and authorization for sensitive features
-6. **HTTPS**: Always serve hyperfrontend features over HTTPS in production
+These are the decisions the SDK cannot make for you. Everything the protocol already enforces —
+origin pinning, window binding, instance identity, the gated handshake, payload validation on both
+ends — is on by default and is not something you should be re-implementing by hand.
+
+1. **Restrict who may embed the feature.** Send
+   `Content-Security-Policy: frame-ancestors <hosts>` on the response that serves the feature
+   document. Origin pinning keeps a conversation consistent; only `frame-ancestors` decides whether
+   a page was ever allowed to frame you.
+2. **Authorise on the server.** A message that crossed the boundary is not an authorised operation.
+   Protected work needs credentials the feature's own backend validates.
+3. **Choose the envelope deliberately.** `v2` with a pre-shared key is the confidentiality control;
+   `v1` is time-window obfuscation and buys deterrence only. Provision and rotate the `v2` key
+   yourself; a key is never baked into a built artifact. A handshake that cannot agree on an
+   encrypted transport falls back to plaintext; where that would be unacceptable, drive
+   `@hyperfrontend/nexus` directly and set `security.mode: 'fail-closed'` on the channel so the
+   connection is denied instead.
+4. **Declare schemas and a contract version.** Actions without a schema pass unvalidated, and a side
+   without a version always passes the compatibility gate. Both are how drift is caught early.
+5. **Grant capability narrowly.** Delegate only the Permissions-Policy features the integration
+   needs, and price a `sandbox` posture against what the product actually requires.
+6. **Serve everything over HTTPS**, host and feature alike.
+7. **Keep dependencies updated** on both sides of the boundary, and pair that with the page-integrity
+   controls this model deliberately leaves to you: Content Security Policy, Trusted Types,
+   Subresource Integrity, and dependency provenance.
 
 ## Security Updates
 
@@ -73,10 +112,6 @@ Security updates will be released as patch versions and documented in the [CHANG
 
 ## Supported Versions
 
-We currently provide security updates for:
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 0.0.x   | :white_check_mark: |
-
-As the project matures, we will update this table to reflect our long-term support policy.
+Security updates are provided for the latest published version of each `@hyperfrontend/*` package.
+Older releases receive no backports. A long-term support policy will replace this section once the
+packages settle on a stable release cadence.

package/_dependencies/@hyperfrontend/data-utils/index.cjs.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const { isArray } = require('../immutable-api-utils/built-in-copy/array/index.cjs.js');
+const { createError } = require('../immutable-api-utils/built-in-copy/error/index.cjs.js');
+const { freeze, keys: keys$1 } = require('../immutable-api-utils/built-in-copy/object/index.cjs.js');
+const { createMap } = require('../immutable-api-utils/built-in-copy/map/index.cjs.js');
+const { createDate } = require('../immutable-api-utils/built-in-copy/date/index.cjs.js');
+const { random, round } = require('../immutable-api-utils/built-in-copy/math/index.cjs.js');
+
+const isMarker = (text) => {
+    if (typeof text !== 'string' || !text.startsWith('__$'))
+        return false;
+    return /^__\$[0-9]+$/.test(text);
+};
+
+const registeredClasses = [];
+const registeredIterableClasses = [
+    {
+        classRef: Array,
+        instantiate: () => [],
+        getKeys: (target) => {
+            const keysArray = keys$1(target);
+            if (getConfig().detectCircularReferences) {
+                return keysArray.filter((key) => !isMarker(key));
+            }
+            return keysArray;
+        },
+        read: (target, key) => target[key],
+        write: (target, value, key) => (target[key] = value),
+        remove: (target, value) => target.splice(value, 1),
+    },
+    {
+        classRef: Object,
+        instantiate: () => ({}),
+        getKeys: (target) => {
+            const keysArray = keys$1(target);
+            if (getConfig().detectCircularReferences) {
+                return keysArray.filter((key) => !isMarker(key));
+            }
+            return keysArray;
+        },
+        read: (target, key) => target[key],
+        write: (target, value, key) => (target[key] = value),
+        remove: (target, value) => delete target[value],
+    },
+];
+let samePositionOfOwnProperties = false;
+let detectCircularReferences = false;
+const getConfig = () => ({
+    samePositionOfOwnProperties,
+    detectCircularReferences,
+});
+
+const getKeysFromIterable = (target, dataType) => {
+    if (dataType === 'array')
+        dataType = Array.name;
+    if (dataType === 'object')
+        dataType = Object.name;
+    const iterableClass = registeredIterableClasses.find(({ classRef }) => dataType === classRef.name);
+    if (iterableClass === undefined)
+        return [];
+    return iterableClass.getKeys(target);
+};
+
+const getType = (target) => {
+    if (target === null)
+        return 'null';
+    const nativeDataType = typeof target;
+    if (nativeDataType === 'object') {
+        if (isArray(target))
+            return 'array';
+        for (const registeredClass of registeredClasses) {
+            if (target instanceof registeredClass)
+                return registeredClass.name;
+        }
+    }
+    return nativeDataType;
+};
+
+const getIterableTypes = () => registeredIterableClasses.map(({ classRef }) => {
+    const name = classRef.name;
+    if (name === Object.name)
+        return 'object';
+    if (name === Array.name)
+        return 'array';
+    return name;
+});
+
+const isIterableType = (dataType) => getIterableTypes().includes(dataType);
+
+const isIterable = (target) => isIterableType(getType(target));
+
+const marker = () => {
+    const randomValue = round(random() * 10000000000000);
+    const sequential = createDate().getTime();
+    const unique = `${randomValue}${sequential}`;
+    const prefix = `__$`;
+    return `${prefix}${unique}`;
+};
+
+const referenceStack = () => {
+    const records = createMap();
+    const flag = marker();
+    const exists = (ref) => (isIterable(ref) ? flag in ref && records.has(ref[flag]) : false);
+    const add = (ref) => {
+        if (!isIterable(ref) || exists(ref))
+            return;
+        ref[flag] = Symbol();
+        records.set(ref[flag], [flag, ref, records.size]);
+    };
+    const lastSeen = (ref) => {
+        if (!isIterable(ref))
+            return null;
+        const record = records.get(ref[flag]);
+        return record ? record[2] - records.size : null;
+    };
+    const clear = () => (records.forEach(([key, ref]) => {
+        delete ref[key];
+    }),
+        records.clear());
+    return {
+        add: (ref) => add(ref),
+        exists: (ref) => exists(ref),
+        lastSeen: (ref) => lastSeen(ref),
+        clear: () => clear(),
+        get size() {
+            return records.size;
+        },
+    };
+};
+
+const errorMessage = (thing, type) => `Expected ${thing} to be ${type}.`;
+const nextIterationDetails = (path, key, value) => ({
+    nextPath: [...path, key],
+    nextValue: value[key],
+});
+const circularDependencyTraversal = (condition, callback, config, key, path, value, parent, state, stack, root = false) => {
+    if (stack.exists(value))
+        return state;
+    const ok = condition(config, key, value, path, parent);
+    if (config.exitEarly)
+        return state;
+    if (ok)
+        callback(key, value, path, state, parent);
+    stack.add(value);
+    const type = getType(value);
+    if (!isIterableType(type))
+        return state;
+    const keys = getKeysFromIterable(value, type);
+    keys.forEach((key) => {
+        const { nextPath, nextValue } = nextIterationDetails(path, key, value);
+        circularDependencyTraversal(condition, callback, config, key, nextPath, nextValue, value, state, stack);
+    });
+    if (root)
+        stack.clear();
+    return state;
+};
+const nonCircularDependencyTraversal = (condition, callback, config, key, path, value, parent, state) => {
+    const ok = condition(config, key, value, path, parent);
+    if (config.exitEarly)
+        return state;
+    if (ok)
+        callback(key, value, path, state, parent);
+    const type = getType(value);
+    if (!isIterableType(type))
+        return state;
+    const keys = getKeysFromIterable(value, type);
+    keys.forEach((key) => {
+        const { nextPath, nextValue } = nextIterationDetails(path, key, value);
+        nonCircularDependencyTraversal(condition, callback, config, key, nextPath, nextValue, value, state);
+    });
+    return state;
+};
+const traversal = (target, condition, callback, options, state) => {
+    if (typeof callback !== 'function')
+        throw createError(errorMessage('callback', 'a function'));
+    if (!(typeof options === 'object' && !isArray(options)))
+        throw createError(errorMessage('options', 'an object'));
+    if (!isArray(options.depth))
+        throw createError(errorMessage('options.depth', 'an array'));
+    const [startDepth, maxDepth] = options.depth;
+    if (startDepth !== void 0 && typeof startDepth !== 'number')
+        throw createError(errorMessage('options.depth.0', 'a number'));
+    if (maxDepth !== void 0) {
+        const maxDepthType = typeof maxDepth;
+        if (!['number', 'string'].includes(maxDepthType))
+            throw createError(errorMessage('options.depth.1', 'a number or a string'));
+        if (maxDepthType === 'string' && maxDepth !== '*')
+            throw createError("Only valid string value in options.depth.1 is '*'.");
+    }
+    const config = {
+        depth: freeze([options.depth[0] ?? 0, options.depth[1] ?? '*']),
+        exitEarly: false,
+    };
+    const initialArgs = [condition, callback, config, '', [], target, void 0, state];
+    if (getConfig().detectCircularReferences)
+        return circularDependencyTraversal(...initialArgs, referenceStack(), true);
+    return nonCircularDependencyTraversal(...initialArgs);
+};
+const createTraversal = (condition) => (target, callback, options, state) => traversal(target, condition, callback, options ?? { depth: [0, '*'] }, state ?? {});
+const condition = (config, key, value, path) => !(path.length < config.depth[0] || config.depth[1] < path.length);
+const traverseBetweenDepthRange = createTraversal(condition);
+exports.createTraversal = createTraversal;
+exports.getConfig = getConfig;
+exports.getIterableTypes = getIterableTypes;
+exports.getKeysFromIterable = getKeysFromIterable;
+exports.getType = getType;
+exports.isIterable = isIterable;
+exports.isIterableType = isIterableType;
+exports.isMarker = isMarker;
+exports.marker = marker;
+exports.referenceStack = referenceStack;
+exports.registeredClasses = registeredClasses;
+exports.registeredIterableClasses = registeredIterableClasses;

package/_dependencies/@hyperfrontend/data-utils/index.esm.js

@@ -0,0 +1,202 @@
+import { isArray } from '../immutable-api-utils/built-in-copy/array/index.esm.js';
+import { createError } from '../immutable-api-utils/built-in-copy/error/index.esm.js';
+import { keys, freeze } from '../immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createMap } from '../immutable-api-utils/built-in-copy/map/index.esm.js';
+import { createDate } from '../immutable-api-utils/built-in-copy/date/index.esm.js';
+import { round, random } from '../immutable-api-utils/built-in-copy/math/index.esm.js';
+
+const isMarker = (text) => {
+    if (typeof text !== 'string' || !text.startsWith('__$'))
+        return false;
+    return /^__\$[0-9]+$/.test(text);
+};
+
+const registeredClasses = [];
+const registeredIterableClasses = [
+    {
+        classRef: Array,
+        instantiate: () => [],
+        getKeys: (target) => {
+            const keysArray = keys(target);
+            if (getConfig().detectCircularReferences) {
+                return keysArray.filter((key) => !isMarker(key));
+            }
+            return keysArray;
+        },
+        read: (target, key) => target[key],
+        write: (target, value, key) => (target[key] = value),
+        remove: (target, value) => target.splice(value, 1),
+    },
+    {
+        classRef: Object,
+        instantiate: () => ({}),
+        getKeys: (target) => {
+            const keysArray = keys(target);
+            if (getConfig().detectCircularReferences) {
+                return keysArray.filter((key) => !isMarker(key));
+            }
+            return keysArray;
+        },
+        read: (target, key) => target[key],
+        write: (target, value, key) => (target[key] = value),
+        remove: (target, value) => delete target[value],
+    },
+];
+let samePositionOfOwnProperties = false;
+let detectCircularReferences = false;
+const getConfig = () => ({
+    samePositionOfOwnProperties,
+    detectCircularReferences,
+});
+
+const getKeysFromIterable = (target, dataType) => {
+    if (dataType === 'array')
+        dataType = Array.name;
+    if (dataType === 'object')
+        dataType = Object.name;
+    const iterableClass = registeredIterableClasses.find(({ classRef }) => dataType === classRef.name);
+    if (iterableClass === undefined)
+        return [];
+    return iterableClass.getKeys(target);
+};
+
+const getType = (target) => {
+    if (target === null)
+        return 'null';
+    const nativeDataType = typeof target;
+    if (nativeDataType === 'object') {
+        if (isArray(target))
+            return 'array';
+        for (const registeredClass of registeredClasses) {
+            if (target instanceof registeredClass)
+                return registeredClass.name;
+        }
+    }
+    return nativeDataType;
+};
+
+const getIterableTypes = () => registeredIterableClasses.map(({ classRef }) => {
+    const name = classRef.name;
+    if (name === Object.name)
+        return 'object';
+    if (name === Array.name)
+        return 'array';
+    return name;
+});
+
+const isIterableType = (dataType) => getIterableTypes().includes(dataType);
+
+const isIterable = (target) => isIterableType(getType(target));
+
+const marker = () => {
+    const randomValue = round(random() * 10000000000000);
+    const sequential = createDate().getTime();
+    const unique = `${randomValue}${sequential}`;
+    const prefix = `__$`;
+    return `${prefix}${unique}`;
+};
+
+const referenceStack = () => {
+    const records = createMap();
+    const flag = marker();
+    const exists = (ref) => (isIterable(ref) ? flag in ref && records.has(ref[flag]) : false);
+    const add = (ref) => {
+        if (!isIterable(ref) || exists(ref))
+            return;
+        ref[flag] = Symbol();
+        records.set(ref[flag], [flag, ref, records.size]);
+    };
+    const lastSeen = (ref) => {
+        if (!isIterable(ref))
+            return null;
+        const record = records.get(ref[flag]);
+        return record ? record[2] - records.size : null;
+    };
+    const clear = () => (records.forEach(([key, ref]) => {
+        delete ref[key];
+    }),
+        records.clear());
+    return {
+        add: (ref) => add(ref),
+        exists: (ref) => exists(ref),
+        lastSeen: (ref) => lastSeen(ref),
+        clear: () => clear(),
+        get size() {
+            return records.size;
+        },
+    };
+};
+
+const errorMessage = (thing, type) => `Expected ${thing} to be ${type}.`;
+const nextIterationDetails = (path, key, value) => ({
+    nextPath: [...path, key],
+    nextValue: value[key],
+});
+const circularDependencyTraversal = (condition, callback, config, key, path, value, parent, state, stack, root = false) => {
+    if (stack.exists(value))
+        return state;
+    const ok = condition(config, key, value, path, parent);
+    if (config.exitEarly)
+        return state;
+    if (ok)
+        callback(key, value, path, state, parent);
+    stack.add(value);
+    const type = getType(value);
+    if (!isIterableType(type))
+        return state;
+    const keys = getKeysFromIterable(value, type);
+    keys.forEach((key) => {
+        const { nextPath, nextValue } = nextIterationDetails(path, key, value);
+        circularDependencyTraversal(condition, callback, config, key, nextPath, nextValue, value, state, stack);
+    });
+    if (root)
+        stack.clear();
+    return state;
+};
+const nonCircularDependencyTraversal = (condition, callback, config, key, path, value, parent, state) => {
+    const ok = condition(config, key, value, path, parent);
+    if (config.exitEarly)
+        return state;
+    if (ok)
+        callback(key, value, path, state, parent);
+    const type = getType(value);
+    if (!isIterableType(type))
+        return state;
+    const keys = getKeysFromIterable(value, type);
+    keys.forEach((key) => {
+        const { nextPath, nextValue } = nextIterationDetails(path, key, value);
+        nonCircularDependencyTraversal(condition, callback, config, key, nextPath, nextValue, value, state);
+    });
+    return state;
+};
+const traversal = (target, condition, callback, options, state) => {
+    if (typeof callback !== 'function')
+        throw createError(errorMessage('callback', 'a function'));
+    if (!(typeof options === 'object' && !isArray(options)))
+        throw createError(errorMessage('options', 'an object'));
+    if (!isArray(options.depth))
+        throw createError(errorMessage('options.depth', 'an array'));
+    const [startDepth, maxDepth] = options.depth;
+    if (startDepth !== void 0 && typeof startDepth !== 'number')
+        throw createError(errorMessage('options.depth.0', 'a number'));
+    if (maxDepth !== void 0) {
+        const maxDepthType = typeof maxDepth;
+        if (!['number', 'string'].includes(maxDepthType))
+            throw createError(errorMessage('options.depth.1', 'a number or a string'));
+        if (maxDepthType === 'string' && maxDepth !== '*')
+            throw createError("Only valid string value in options.depth.1 is '*'.");
+    }
+    const config = {
+        depth: freeze([options.depth[0] ?? 0, options.depth[1] ?? '*']),
+        exitEarly: false,
+    };
+    const initialArgs = [condition, callback, config, '', [], target, void 0, state];
+    if (getConfig().detectCircularReferences)
+        return circularDependencyTraversal(...initialArgs, referenceStack(), true);
+    return nonCircularDependencyTraversal(...initialArgs);
+};
+const createTraversal = (condition) => (target, callback, options, state) => traversal(target, condition, callback, options ?? { depth: [0, '*'] }, state ?? {});
+const condition = (config, key, value, path) => !(path.length < config.depth[0] || config.depth[1] < path.length);
+const traverseBetweenDepthRange = createTraversal(condition);
+
+export { createTraversal, getConfig, getIterableTypes, getKeysFromIterable, getType, isIterable, isIterableType, isMarker, marker, referenceStack, registeredClasses, registeredIterableClasses };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const _Array = globalThis.Array;
+const isArray = _Array.isArray;
+const from = _Array.from;
+exports.from = from;
+exports.isArray = isArray;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js

@@ -0,0 +1,5 @@
+const _Array = globalThis.Array;
+const isArray = _Array.isArray;
+const from = _Array.from;
+
+export { from, isArray };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/date/index.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const _Date = globalThis.Date;
+const _Reflect = globalThis.Reflect;
+function createDate(...args) {
+    return _Reflect.construct(_Date, args);
+}
+exports.createDate = createDate;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/date/index.esm.js

@@ -0,0 +1,7 @@
+const _Date = globalThis.Date;
+const _Reflect = globalThis.Reflect;
+function createDate(...args) {
+    return _Reflect.construct(_Date, args);
+}
+
+export { createDate };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const _Error = globalThis.Error;
+const _Reflect = globalThis.Reflect;
+const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
+exports.createError = createError;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js

@@ -0,0 +1,5 @@
+const _Error = globalThis.Error;
+const _Reflect = globalThis.Reflect;
+const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
+
+export { createError };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.cjs.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const _Map = globalThis.Map;
+const _Reflect = globalThis.Reflect;
+const createMap = (iterable) => _Reflect.construct(_Map, iterable ? [iterable] : []);
+exports.createMap = createMap;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.esm.js

@@ -0,0 +1,5 @@
+const _Map = globalThis.Map;
+const _Reflect = globalThis.Reflect;
+const createMap = (iterable) => _Reflect.construct(_Map, iterable ? [iterable] : []);
+
+export { createMap };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const _Math = globalThis.Math;
+const round = _Math.round;
+const random = _Math.random;
+exports.random = random;
+exports.round = round;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.esm.js

@@ -0,0 +1,5 @@
+const _Math = globalThis.Math;
+const round = _Math.round;
+const random = _Math.random;
+
+export { random, round };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const _Object = globalThis.Object;
+const freeze = _Object.freeze;
+const keys = _Object.keys;
+exports.freeze = freeze;
+exports.keys = keys;