ohlcv-indicators 3.5.78 → 3.5.80

package/src/oscillators/stochastic.js

@@ -1,5 +1,7 @@
-import { FasterStochasticOscillator } from 'trading-signals';
+import { FasterStochasticOscillator } from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {lag, retLogs}) => {
 
@@ -13,39 +15,24 @@ export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {lag,
 
   // Initialization on the first index.
     if (index === 0) {
-
-        const {len } = main;
+        validateInputValues({ high: true, low: true, close: true }, verticalOhlcv, index, 'stochastic');
 
         Object.assign(instances, {
             [instanceKey]: new FasterStochasticOscillator(kPeriod, kSlowingPeriod, dPeriod)
         })
 
-        Object.assign(verticalOhlcv, {
-            [stochD]: new Float64Array(len).fill(NaN),
-            [stochK]: new Float64Array(len).fill(NaN),
-        })
-
-        const baseKeys = [stochD, stochK]
-
-        if (lag > 0) {
-            main.lag(baseKeys, lag);
-        }
+        initializeColumns(main, [{ key: stochD }, { key: stochK }], { lag });
 
     }
 
     const close = verticalOhlcv['close'][index]
     const low = verticalOhlcv['low'][index]
     const high = verticalOhlcv['high'][index]
-    let stockObj = null
 
   // Update the stochastic indicator.
     instances[instanceKey].update({close, low, high})
 
-    try {
-        stockObj = instances[instanceKey].getResult()
-    } catch (err) {
-        stockObj = null
-    }
+    const stockObj = instances[instanceKey].isStable ? instances[instanceKey].getResult() : null
 
     const kVal = stockObj ? (retLogs ? mathLog(stockObj.stochK, 50) : stockObj.stochK) : NaN
     const dVal = stockObj ? (retLogs ? mathLog(stockObj.stochD, 50) : stockObj.stochD) : NaN

package/src/oscillators/volumeDelta.js

@@ -1,29 +1,41 @@
+import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+
+
 export const volumeDelta = (main, index, { lag = 0 }) => {
-  const { verticalOhlcv, instances, len } = main;
-  const groupName = 'volume_delta';
+  const { verticalOhlcv, instances } = main;
+  const key = 'volume_delta';
 
   if (index === 0) {
-    if (!instances[groupName]) instances[groupName] = { isBuyVolume: true, cross: 0 };
-
-    const keys = [
-      `${groupName}_open`,
-      `${groupName}_high`,
-      `${groupName}_low`,
-      `${groupName}_close`,
-      `${groupName}_cross`,
-    ];
+    validateInputValues({ open: true, close: true, volume: true }, verticalOhlcv, index, 'volumeDelta');
 
-    // allocate outputs
-    for (const k of keys) verticalOhlcv[k] = new Float64Array(len).fill(NaN);
+    if (!instances[key]) {
+      instances[key] = { isBuyVolume: true, cross: 0};
+    }
+
+    const keyNames = [
+      `${key}_high`,
+      `${key}_low`,
+      `${key}_close`,
+      `${key}_cross`,
+    ];
 
-    // optional lag
-    if (lag > 0) main.lag(keys, lag);
+    initializeColumns(main, keyNames.map(key => ({ key })), { lag });
   }
 
-  const inst = instances[groupName];
+  const inst = instances[key];
+
+  const {hasInvalidInputValue} = inst
 
   // inputs
-  const vol       = verticalOhlcv.volume[index];
+  const volume = verticalOhlcv.volume[index];
+
+  if(volume === 0) {
+    return;
+  }
+
+
   const open      = verticalOhlcv.open[index];
   const close     = verticalOhlcv.close[index];
   const prevClose = index > 0 ? verticalOhlcv.close[index - 1] : NaN;
@@ -55,20 +67,16 @@ export const volumeDelta = (main, index, { lag = 0 }) => {
     }
   }
   
-
-  const delta = Number.isFinite(vol) ? (isBuy ? vol : -vol) : NaN;
+  const delta = isBuy ? volume : -volume;
 
   // delta "candle"
-  const openVal  = Number.isNaN(delta) ? NaN : 0;
   const closeVal = delta;
-  const highVal  = Number.isNaN(delta) ? NaN : Math.max(delta, 0);
-  const lowVal   = Number.isNaN(delta) ? NaN : Math.min(delta, 0);
+  const highVal  = Math.max(delta, 0);
+  const lowVal   = Math.min(delta, 0);
 
-  main.pushToMain({ index, key: `${groupName}_open`,  value: openVal });
-  main.pushToMain({ index, key: `${groupName}_high`,  value: highVal });
-  main.pushToMain({ index, key: `${groupName}_low`,   value: lowVal });
-  main.pushToMain({ index, key: `${groupName}_close`, value: closeVal });
-  main.pushToMain({ index, key: `${groupName}_cross`, value: inst.cross });
+  main.pushToMain({ index, key: `${key}_high`,  value: highVal });
+  main.pushToMain({ index, key: `${key}_low`,   value: lowVal });
+  main.pushToMain({ index, key: `${key}_close`, value: closeVal });
+  main.pushToMain({ index, key: `${key}_cross`, value: inst.cross });
 
-  return true;
 };

package/src/oscillators/volumeOscillator.js

@@ -1,59 +1,51 @@
-import { FasterEMA } from 'trading-signals';
+import { FasterEMA } from '../core-indicators/index.js';
+import { mathLog } from '../utilities/math.js';
+import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
-export const volumeOscillator = (main, index, fast, slow, {lag}) => {
-
-    
+export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
 
     const {verticalOhlcv, instances} = main
-    const value = verticalOhlcv.volume[index]
-    const key = `volume_oscillator_${fast}_${slow}`
+    const key = retLogs ? `ret_log_volume_oscillator_${fast}_${slow}` : `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
+        validateInputValues({ volume: true }, verticalOhlcv, index, 'volumeOscillator');
 
-        const {len} = main
         Object.assign(instances, {
             [key]: {
                 fastEMA: new FasterEMA(fast),
-                slowEMA: new FasterEMA(slow)
+                slowEMA: new FasterEMA(slow),
             }
         })
 
-        verticalOhlcv[key] = new Float64Array(len).fill(NaN)
-
-        if(lag > 0)
-        {
-            main.lag([key], lag)
-        }
+        initializeColumns(main, [{ key }], { lag });
     }
 
     const { fastEMA, slowEMA } = instances[key];
 
-    fastEMA.update(value);
-    slowEMA.update(value);
-
-    let fastValue = NaN;
-    let slowValue = NaN;
+    const volume = verticalOhlcv.volume[index];
 
-    try {
-        fastValue = fastEMA.getResult();
-    } catch (err) {
-        
+    if(volume === 0) {
+        return;
     }
 
-    try {
-        slowValue = slowEMA.getResult();
-    } catch (err) {
+    fastEMA.update(volume);
+    slowEMA.update(volume);
 
-    }
+    const fastValue = fastEMA.isStable ? fastEMA.getResult() : NaN;
+    const slowValue = slowEMA.isStable ? slowEMA.getResult() : NaN;
 
     let volumeOscValue = NaN
+    let volumeOscRetLog = NaN
 
-    if(!Number.isNaN(fastValue) && !Number.isNaN(slowValue))
-    {
-        volumeOscValue = 100 * (fastValue - slowValue) / slowValue
+    if(Number.isNaN(fastValue) || Number.isNaN(slowValue)) {
+        return;
     }
 
-    main.pushToMain({index, key, value:  volumeOscValue})
+    volumeOscValue = retLogs
+        ?  mathLog(fastValue, slowValue)
+        : 100 * (fastValue - slowValue) / slowValue
 
-    return true;
+    main.pushToMain({index, key, value:  volumeOscValue})
 };

package/src/studies/candleFeatures.js

@@ -1,4 +1,5 @@
-
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 const isBadNumber = (v) => v == null || !Number.isFinite(v)
 
@@ -9,19 +10,16 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
     const prefix = (retLogs) ? 'ret_log_' : 'ret_'
 
     if(index === 0) {
-        const {len} = main
-        
-        const newCols = {
-            [`${prefix}change`]: new Float64Array(len).fill(NaN),
-            [`${prefix}mid_price_change`]: new Float64Array(len).fill(NaN),
-            [`${prefix}upper_wick`]: new Float64Array(len).fill(NaN),
-            [`${prefix}lower_wick`]: new Float64Array(len).fill(NaN),
-            [`${prefix}gap`]: new Float64Array(len).fill(NaN),
-            [`${prefix}body`]: new Float64Array(len).fill(NaN),
-            [`${prefix}range`]: new Float64Array(len).fill(NaN)
-        }
+        validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'candleFeatures')
+
+        const columns = [
+            'change', 'mid_price_change', 'upper_wick', 'lower_wick',
+            'gap', 'body', 'range'
+        ].map(name => ({ key: `${prefix}${name}` }))
 
         for(const target of colKeys) {
+            validateInputValues({ [target]: true }, verticalOhlcv, index, 'candleFeatures')
+
             if(!verticalOhlcv.hasOwnProperty(target)) {
                 throw new Error(
                     `Target property in "options.colKey" array "${target}" not found in verticalOhlcv for "candleFeatures".`
@@ -34,16 +32,10 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
                 );               
             }
 
-            newCols[`${prefix}${target}`] = new Float64Array(len).fill(NaN)
+            columns.push({ key: `${prefix}${target}` })
         }
 
-        Object.assign(verticalOhlcv, newCols)
-
-        scaledGroups.candleFeatures = Object.keys(newCols)
-
-        if(lag) {
-            main.lag(Object.keys(newCols), lag)
-        }
+        scaledGroups.candleFeatures = initializeColumns(main, columns, { lag })
     }
 
     const prevClose = verticalOhlcv.close[index - 1]
@@ -64,14 +56,34 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
     const upperWickTop = Math.max(currOpen, currClose)
     const lowerWickTop = Math.min(currOpen, currClose)
 
+    const change = getRet(currClose, prevClose)
+    const midPriceChange = getRet(currMidPrice, prevMidPrice)
+    const upperWick = getRet(currHigh, upperWickTop)
+    const lowerWick = getRet(lowerWickTop, currLow)
+    const gap = getRet(currOpen, prevClose)
+    const body = getRet(currClose, currOpen)
+    const range = getRet(currHigh, currLow)
+
+    if (colKeys.length === 0) {
+        main.pushToMain({ index, key: `${prefix}change`, value: change })
+        main.pushToMain({ index, key: `${prefix}mid_price_change`, value: midPriceChange })
+        main.pushToMain({ index, key: `${prefix}upper_wick`, value: upperWick })
+        main.pushToMain({ index, key: `${prefix}lower_wick`, value: lowerWick })
+        main.pushToMain({ index, key: `${prefix}gap`, value: gap })
+        main.pushToMain({ index, key: `${prefix}body`, value: body })
+        main.pushToMain({ index, key: `${prefix}range`, value: range })
+        return
+    }
+
+    // Keep optional-target overwrite/order semantics and all-or-nothing validation.
     const row = {
-        [`${prefix}change`]: getRet(currClose, prevClose),
-        [`${prefix}mid_price_change`]: getRet(currMidPrice, prevMidPrice),
-        [`${prefix}upper_wick`]: getRet(currHigh, upperWickTop),
-        [`${prefix}lower_wick`]: getRet(lowerWickTop, currLow),
-        [`${prefix}gap`]: getRet(currOpen, prevClose),
-        [`${prefix}body`]: getRet(currClose, currOpen),
-        [`${prefix}range`]: getRet(currHigh, currLow)
+        [`${prefix}change`]: change,
+        [`${prefix}mid_price_change`]: midPriceChange,
+        [`${prefix}upper_wick`]: upperWick,
+        [`${prefix}lower_wick`]: lowerWick,
+        [`${prefix}gap`]: gap,
+        [`${prefix}body`]: body,
+        [`${prefix}range`]: range
     }
 
     let hasInvalidTarget = false
@@ -94,4 +106,4 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
          main.pushToMain({index, key, value})
     }
 
-}
+}

package/src/studies/dateTime.js

@@ -1,4 +1,7 @@
 import {oneHotEncode} from '../machine-learning/ml-utilities.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
+
+const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
 
 export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
@@ -9,11 +12,16 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     if(index === 0)
     {
-        const {len, dateType} = main
+        const {dateType} = main
         if(!dateType) throw Error('dateTime method found and invalid "date" in input ohlcv')
 
         Object.assign(instances, {
             dateTime: {
+                formatter: new Intl.DateTimeFormat('en-US-u-ca-gregory-nu-latn', {
+                    timeZone: main.timeZone,
+                    year: 'numeric', month: 'numeric', day: 'numeric', weekday: 'short',
+                    hour: 'numeric', minute: 'numeric', hourCycle: 'h23'
+                }),
                 colKeys: [...precompute.colKeys, `${prefix}year`].filter(v => v !== 'one_hot_year'),
                 colKeySizes: {
                     ...precompute.colKeySizes
@@ -23,65 +31,55 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
         const { colKeys } = instances.dateTime
 
-        // choose your ctor, fill-value and type-name once
-        const ctor     = oneHot ? Array     : Int16Array
-        const fillVal  = oneHot ? null      : NaN
-
-        // single loop instead of three
-        for (const key of colKeys) {
-
-            verticalOhlcv[key] = new ctor(len).fill(fillVal)
-
-        }
-
-        // finally, apply lag once
-        if (lag > 0) {
-        main.lag(colKeys, lag)
-        }
+        initializeColumns(main, colKeys.map(key => ({
+            key,
+            type: oneHot ? 'Array' : 'Int16Array',
+            fill: oneHot ? null : 0
+        })), { lag })
     }
 
-    const {colKeySizes} = instances.dateTime
+    const {colKeySizes, formatter} = instances.dateTime
 
     const currDate = verticalOhlcv.date[index]
 
-    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes)
-
-    for(const [key, value] of Object.entries(dateInfo))
-    {
-        main.pushToMain({index, key, value})
+    let yearPart, monthPart, hourPart, minutePart, weekdayPart, dayPart
+    for (const part of formatter.formatToParts(currDate)) {
+        switch (part.type) {
+            case 'year': yearPart = part.value; break
+            case 'month': monthPart = part.value; break
+            case 'hour': hourPart = part.value; break
+            case 'minute': minutePart = part.value; break
+            case 'weekday': weekdayPart = part.value; break
+            case 'day': dayPart = part.value; break
+        }
+    }
+    const year = Number(yearPart)
+    const month = Number(monthPart) - 1
+    const hour = Number(hourPart)
+    const minute = Number(minutePart)
+    const dayOfWeek = weekdays.indexOf(weekdayPart)
+    const dayOfMonth = Number(dayPart) - 1
+
+    if (!oneHot) {
+        main.pushToMain({ index, key: 'year', value: year })
+        main.pushToMain({ index, key: 'month', value: month + 1 })
+        main.pushToMain({ index, key: 'hour', value: hour })
+        main.pushToMain({ index, key: 'minute', value: minute })
+        main.pushToMain({ index, key: 'day_of_the_week', value: ((dayOfWeek + 6) % 7) + 1 })
+        main.pushToMain({ index, key: 'day_of_the_month', value: dayOfMonth + 1 })
+        return
     }
-}
-
-
-
-const getDateInfo = (date, oneHot, colKeySizes) => {
-
-
-  const year = date.getFullYear();
-
-  //start with 0 values
-  const month = date.getMonth();
-  const hour = date.getHours();
-  const minute = date.getMinutes();
-  const dayOfWeek = date.getDay();
-  const dayOfMonth = date.getDate() - 1; // keep same offset
-
-  if (!oneHot) {
-    return {
-      year: year,
-      month: month + 1,  //iso month
-      hour: hour,
-      minute: minute,
-      day_of_the_week: ((dayOfWeek + 6) % 7) + 1, //iso date of the week
-      day_of_the_month: dayOfMonth + 1,  //iso date of the month
-    };
-  }
 
-  return {
-    one_hot_month: oneHotEncode(month, colKeySizes.one_hot_month),
-    one_hot_hour: oneHotEncode(hour, colKeySizes.one_hot_hour),
-    one_hot_minute: oneHotEncode(minute, colKeySizes.one_hot_minute),
-    one_hot_day_of_the_week: oneHotEncode(dayOfWeek, colKeySizes.one_hot_day_of_the_week),
-    one_hot_day_of_the_month: oneHotEncode(dayOfMonth, colKeySizes.one_hot_day_of_the_month),
-  };
-};
+    // Build a fresh vector for every field and row before writing.
+    const oneHotMonth = oneHotEncode(month, colKeySizes.one_hot_month)
+    const oneHotHour = oneHotEncode(hour, colKeySizes.one_hot_hour)
+    const oneHotMinute = oneHotEncode(minute, colKeySizes.one_hot_minute)
+    const oneHotWeekday = oneHotEncode(dayOfWeek, colKeySizes.one_hot_day_of_the_week)
+    const oneHotDay = oneHotEncode(dayOfMonth, colKeySizes.one_hot_day_of_the_month)
+
+    main.pushToMain({ index, key: 'one_hot_month', value: oneHotMonth })
+    main.pushToMain({ index, key: 'one_hot_hour', value: oneHotHour })
+    main.pushToMain({ index, key: 'one_hot_minute', value: oneHotMinute })
+    main.pushToMain({ index, key: 'one_hot_day_of_the_week', value: oneHotWeekday })
+    main.pushToMain({ index, key: 'one_hot_day_of_the_month', value: oneHotDay })
+}

package/src/studies/findCrosses.js

@@ -1,6 +1,8 @@
 import { oneHotEncode } from "../machine-learning/ml-utilities.js"
 import { buildArray } from "../utilities/assignTypes.js"
 import { addPrecisionAsNumber } from "../utilities/precisionMultiplier.js"
+import { validateInputValues } from "../utilities/validators.js"
+import { initializeColumns } from "../core-functions/initializeColumns.js"
 const eq = (fast, slow) => fast === slow
 const gt = (fast, slow) => fast > slow
 const lt = (fast, slow) => fast < slow
@@ -22,11 +24,7 @@ class CrossInstance {
             prevSlow: NaN,
             prevHigh: NaN,
             prevLow: NaN,
-            areHighAndLowUndefined: false,
-            crossIndexes: {
-                up: [],
-                down: []
-            }
+            areHighAndLowUndefined: false
         })        
 
     }
@@ -113,9 +111,6 @@ class CrossInstance {
         }
 
 
-        if(this.interval === 1) this.crossIndexes.up.push(index)
-        if(this.interval === -1) this.crossIndexes.down.push(index)
-
         //save prev state
         Object.assign(this, {
             prevState: currState,
@@ -143,6 +138,16 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
     if(index === 0)
     {
+        validateInputValues(
+            {
+                ...(fast === 'price' ? { high: true, low: true, close: true } : { [fast]: true }),
+                ...(typeof slow === 'number' ? {} : { [slow]: true })
+            },
+            verticalOhlcv,
+            index,
+            'crossPairs'
+        )
+
         // allow numeric 'slow' as a constant column
         if (typeof slow === 'number') {
 
@@ -173,12 +178,10 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
         const crossArrType = (limit !== null && limit <= 125) ? 'Int8Array' : 'Float64Array'
 
-        verticalOhlcv[crossName] = buildArray(crossArrType, len, 0)
-
-        if(oneHot)
-        {
-            verticalOhlcv[`one_hot_${crossName}`] = buildArray('Array', len, null)
-        }
+        initializeColumns(main, [
+            { key: crossName, type: crossArrType, fill: 0 },
+            { key: `one_hot_${crossName}`, type: 'Array', enabled: oneHot }
+        ])
 
     }  else if(index + 1 === len) {
         // sanity checks
@@ -228,5 +231,4 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
   }
 
-  return true
-}
+}

package/src/studies/lag.js

@@ -1,44 +1,57 @@
-import { buildArray, getArrayType } from "../utilities/assignTypes.js"
+import { initializeColumns } from "../core-functions/initializeColumns.js"
+
+const lagColumnsKey = Symbol('lagColumns')
 
 export const lag = (main, index, colKeys, lookback) => {
 
-  
-  
-  const { verticalOhlcv, len, priceBased } = main
+  const { verticalOhlcv, priceBased, instances } = main
 
   if(index === 0)
   {
-    for (const targetKey of colKeys) {
-      if (!verticalOhlcv.hasOwnProperty(targetKey)) {
+    const lagColumns = new Map()
+
+    for (const target of colKeys) {
+      if (!verticalOhlcv.hasOwnProperty(target)) {
         throw new Error(
-        `Lag processing invoked by col "${targetKey}" was not found in "verticalOhlcv".`
+        `Lag processing invoked by col "${target}" was not found in "verticalOhlcv".`
         )
       }
 
-      const addToPriceBased = priceBased.has(targetKey)
+      const addToPriceBased = priceBased.has(target)
+      const type = Array.isArray(verticalOhlcv[target]) ? 'Array' : 'Float64Array'
+      const columns = []
+      const keyNames = []
 
       for (let step = 1; step <= lookback; step++) {
-        const key = `${targetKey}_lag_${step}`
-
-        if(addToPriceBased) priceBased.add(key)
-
-        const thisArrType = getArrayType(targetKey, verticalOhlcv[targetKey])
+        const key = `${target}_lag_${step}`
 
-        verticalOhlcv[key] = buildArray(thisArrType, len)
+        columns.push({ key, type, priceBased: addToPriceBased, includeInLag: false })
+        keyNames.push(key)
       }   
+
+      initializeColumns(main, columns)
+      lagColumns.set(target, keyNames)
     }
+
+    // colKeys belongs to the runtime queue; keep cached names out of exported params.
+    if (!instances[lagColumnsKey]) instances[lagColumnsKey] = new WeakMap()
+    instances[lagColumnsKey].set(colKeys, lagColumns)
   }
 
-  for (const targetKey of colKeys) {
-    const currentColumn = verticalOhlcv[targetKey]
+  const lagColumns = instances[lagColumnsKey]?.get(colKeys)
+
+  for (const target of colKeys) {
+    const keyNames = lagColumns?.get(target)
+    const currentColumn = verticalOhlcv[target]
+    const missingValue = Array.isArray(currentColumn) ? null : NaN
 
     // Populate the lagged values each tick:
     for (let step = 1; step <= lookback; step++) {
-      const key = `${targetKey}_lag_${step}`
+      const key = keyNames?.[step - 1] ?? `${target}_lag_${step}`
       const laggedIndex = index - step
       const value =
-        laggedIndex < 0 || currentColumn[laggedIndex] === undefined
-          ? null
+        laggedIndex < 0 || currentColumn[laggedIndex] == null
+          ? missingValue
           : currentColumn[laggedIndex]
 
       main.pushToMain({ index, key, value })
@@ -46,5 +59,4 @@ export const lag = (main, index, colKeys, lookback) => {
     }
   }
 
-  return true
 }

package/src/utilities/assignTypes.js

@@ -29,7 +29,7 @@ export const buildArray = (arrayType, len, fallbackValue) => {
 
   
   // Ctor.from({ length }, mapFn) works for Array *and* all TypedArrays
-  return Ctor.from({ length: len }, () => fillValue)
+  return new Ctor(len).fill(fillValue)
 }
 
 export const assignTypes = main => {

package/src/utilities/config.js

@@ -0,0 +1,31 @@
+export const CONFIG_VERSION = 1;
+
+// Copy configuration without JSON's silent conversion of functions/NaN to null.
+export const copyConfig = (value, ancestors = new Set()) => {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'object' || value === null) {
+    throw new TypeError('Configuration values must be JSON-safe: no undefined, non-finite numbers, or functions.');
+  }
+  if (ancestors.has(value)) throw new TypeError('Configuration must not contain circular references.');
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError('Configuration must contain only plain objects and arrays.');
+  }
+  if (Object.getOwnPropertySymbols(value).length) throw new TypeError('Configuration must not contain symbol keys.');
+
+  ancestors.add(value);
+  const result = Array.isArray(value)
+    ? Array.from(value, item => copyConfig(item, ancestors))
+    : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyConfig(item, ancestors)]));
+  ancestors.delete(value);
+  return result;
+};
+
+export const freezeConfig = value => {
+  if (value !== null && typeof value === 'object') {
+    for (const item of Object.values(value)) freezeConfig(item);
+    Object.freeze(value);
+  }
+  return value;
+};