Skip to content

Method catalog

The full catalog is generated from prompts.json. Every wrapper exposed by neuro-ts is listed below, grouped by built-in. Click through to the full method catalog for full type signatures.

array (40)

  • neuro.array.at
  • neuro.array.concat
  • neuro.array.copyWithin
  • neuro.array.entries
  • neuro.array.every
  • neuro.array.fill
  • neuro.array.filter
  • neuro.array.find
  • neuro.array.findIndex
  • neuro.array.findLast
  • neuro.array.findLastIndex
  • neuro.array.flat
  • neuro.array.flatMap
  • neuro.array.forEach
  • neuro.array.from
  • neuro.array.fromAsync
  • neuro.array.includes
  • neuro.array.indexOf
  • neuro.array.isArray
  • neuro.array.join
  • neuro.array.keys
  • neuro.array.lastIndexOf
  • neuro.array.map
  • neuro.array.of
  • neuro.array.pop
  • neuro.array.push
  • neuro.array.reduce
  • neuro.array.reduceRight
  • neuro.array.reverse
  • neuro.array.shift
  • neuro.array.slice
  • neuro.array.some
  • neuro.array.sort
  • neuro.array.splice
  • neuro.array.toReversed
  • neuro.array.toSorted
  • neuro.array.toSpliced
  • neuro.array.unshift
  • neuro.array.values
  • neuro.array.with

arrayBuffer (5)

  • neuro.arrayBuffer.isView
  • neuro.arrayBuffer.resize
  • neuro.arrayBuffer.slice
  • neuro.arrayBuffer.transfer
  • neuro.arrayBuffer.transferToFixedLength

atomics (14)

  • neuro.atomics.add
  • neuro.atomics.and
  • neuro.atomics.compareExchange
  • neuro.atomics.exchange
  • neuro.atomics.isLockFree
  • neuro.atomics.load
  • neuro.atomics.notify
  • neuro.atomics.or
  • neuro.atomics.pause
  • neuro.atomics.store
  • neuro.atomics.sub
  • neuro.atomics.wait
  • neuro.atomics.waitAsync
  • neuro.atomics.xor

bigInt (2)

  • neuro.bigInt.asIntN
  • neuro.bigInt.asUintN

bigInt64Array (31)

  • neuro.bigInt64Array.at
  • neuro.bigInt64Array.copyWithin
  • neuro.bigInt64Array.entries
  • neuro.bigInt64Array.every
  • neuro.bigInt64Array.fill
  • neuro.bigInt64Array.filter
  • neuro.bigInt64Array.find
  • neuro.bigInt64Array.findIndex
  • neuro.bigInt64Array.findLast
  • neuro.bigInt64Array.findLastIndex
  • neuro.bigInt64Array.forEach
  • neuro.bigInt64Array.from
  • neuro.bigInt64Array.includes
  • neuro.bigInt64Array.indexOf
  • neuro.bigInt64Array.join
  • neuro.bigInt64Array.keys
  • neuro.bigInt64Array.lastIndexOf
  • neuro.bigInt64Array.map
  • neuro.bigInt64Array.of
  • neuro.bigInt64Array.reduce
  • neuro.bigInt64Array.reduceRight
  • neuro.bigInt64Array.reverse
  • neuro.bigInt64Array.set
  • neuro.bigInt64Array.slice
  • neuro.bigInt64Array.some
  • neuro.bigInt64Array.sort
  • neuro.bigInt64Array.subarray
  • neuro.bigInt64Array.toReversed
  • neuro.bigInt64Array.toSorted
  • neuro.bigInt64Array.values
  • neuro.bigInt64Array.with

bigUint64Array (31)

  • neuro.bigUint64Array.at
  • neuro.bigUint64Array.copyWithin
  • neuro.bigUint64Array.entries
  • neuro.bigUint64Array.every
  • neuro.bigUint64Array.fill
  • neuro.bigUint64Array.filter
  • neuro.bigUint64Array.find
  • neuro.bigUint64Array.findIndex
  • neuro.bigUint64Array.findLast
  • neuro.bigUint64Array.findLastIndex
  • neuro.bigUint64Array.forEach
  • neuro.bigUint64Array.from
  • neuro.bigUint64Array.includes
  • neuro.bigUint64Array.indexOf
  • neuro.bigUint64Array.join
  • neuro.bigUint64Array.keys
  • neuro.bigUint64Array.lastIndexOf
  • neuro.bigUint64Array.map
  • neuro.bigUint64Array.of
  • neuro.bigUint64Array.reduce
  • neuro.bigUint64Array.reduceRight
  • neuro.bigUint64Array.reverse
  • neuro.bigUint64Array.set
  • neuro.bigUint64Array.slice
  • neuro.bigUint64Array.some
  • neuro.bigUint64Array.sort
  • neuro.bigUint64Array.subarray
  • neuro.bigUint64Array.toReversed
  • neuro.bigUint64Array.toSorted
  • neuro.bigUint64Array.values
  • neuro.bigUint64Array.with

dataView (22)

  • neuro.dataView.getBigInt64
  • neuro.dataView.getBigUint64
  • neuro.dataView.getFloat16
  • neuro.dataView.getFloat32
  • neuro.dataView.getFloat64
  • neuro.dataView.getInt16
  • neuro.dataView.getInt32
  • neuro.dataView.getInt8
  • neuro.dataView.getUint16
  • neuro.dataView.getUint32
  • neuro.dataView.getUint8
  • neuro.dataView.setBigInt64
  • neuro.dataView.setBigUint64
  • neuro.dataView.setFloat16
  • neuro.dataView.setFloat32
  • neuro.dataView.setFloat64
  • neuro.dataView.setInt16
  • neuro.dataView.setInt32
  • neuro.dataView.setInt8
  • neuro.dataView.setUint16
  • neuro.dataView.setUint32
  • neuro.dataView.setUint8

date (43)

  • neuro.date.UTC
  • neuro.date.getDate
  • neuro.date.getDay
  • neuro.date.getFullYear
  • neuro.date.getHours
  • neuro.date.getMilliseconds
  • neuro.date.getMinutes
  • neuro.date.getMonth
  • neuro.date.getSeconds
  • neuro.date.getTime
  • neuro.date.getTimezoneOffset
  • neuro.date.getUTCDate
  • neuro.date.getUTCDay
  • neuro.date.getUTCFullYear
  • neuro.date.getUTCHours
  • neuro.date.getUTCMilliseconds
  • neuro.date.getUTCMinutes
  • neuro.date.getUTCMonth
  • neuro.date.getUTCSeconds
  • neuro.date.now
  • neuro.date.parse
  • neuro.date.setDate
  • neuro.date.setFullYear
  • neuro.date.setHours
  • neuro.date.setMilliseconds
  • neuro.date.setMinutes
  • neuro.date.setMonth
  • neuro.date.setSeconds
  • neuro.date.setTime
  • neuro.date.setUTCDate
  • neuro.date.setUTCFullYear
  • neuro.date.setUTCHours
  • neuro.date.setUTCMilliseconds
  • neuro.date.setUTCMinutes
  • neuro.date.setUTCMonth
  • neuro.date.setUTCSeconds
  • neuro.date.toDateString
  • neuro.date.toISOString
  • neuro.date.toJSON
  • neuro.date.toLocaleDateString
  • neuro.date.toLocaleTimeString
  • neuro.date.toTimeString
  • neuro.date.toUTCString

float32Array (31)

  • neuro.float32Array.at
  • neuro.float32Array.copyWithin
  • neuro.float32Array.entries
  • neuro.float32Array.every
  • neuro.float32Array.fill
  • neuro.float32Array.filter
  • neuro.float32Array.find
  • neuro.float32Array.findIndex
  • neuro.float32Array.findLast
  • neuro.float32Array.findLastIndex
  • neuro.float32Array.forEach
  • neuro.float32Array.from
  • neuro.float32Array.includes
  • neuro.float32Array.indexOf
  • neuro.float32Array.join
  • neuro.float32Array.keys
  • neuro.float32Array.lastIndexOf
  • neuro.float32Array.map
  • neuro.float32Array.of
  • neuro.float32Array.reduce
  • neuro.float32Array.reduceRight
  • neuro.float32Array.reverse
  • neuro.float32Array.set
  • neuro.float32Array.slice
  • neuro.float32Array.some
  • neuro.float32Array.sort
  • neuro.float32Array.subarray
  • neuro.float32Array.toReversed
  • neuro.float32Array.toSorted
  • neuro.float32Array.values
  • neuro.float32Array.with

float64Array (31)

  • neuro.float64Array.at
  • neuro.float64Array.copyWithin
  • neuro.float64Array.entries
  • neuro.float64Array.every
  • neuro.float64Array.fill
  • neuro.float64Array.filter
  • neuro.float64Array.find
  • neuro.float64Array.findIndex
  • neuro.float64Array.findLast
  • neuro.float64Array.findLastIndex
  • neuro.float64Array.forEach
  • neuro.float64Array.from
  • neuro.float64Array.includes
  • neuro.float64Array.indexOf
  • neuro.float64Array.join
  • neuro.float64Array.keys
  • neuro.float64Array.lastIndexOf
  • neuro.float64Array.map
  • neuro.float64Array.of
  • neuro.float64Array.reduce
  • neuro.float64Array.reduceRight
  • neuro.float64Array.reverse
  • neuro.float64Array.set
  • neuro.float64Array.slice
  • neuro.float64Array.some
  • neuro.float64Array.sort
  • neuro.float64Array.subarray
  • neuro.float64Array.toReversed
  • neuro.float64Array.toSorted
  • neuro.float64Array.values
  • neuro.float64Array.with

globals (8)

  • neuro.decodeURI
  • neuro.decodeURIComponent
  • neuro.encodeURI
  • neuro.encodeURIComponent
  • neuro.isFinite
  • neuro.isNaN
  • neuro.parseFloat
  • neuro.parseInt

int16Array (31)

  • neuro.int16Array.at
  • neuro.int16Array.copyWithin
  • neuro.int16Array.entries
  • neuro.int16Array.every
  • neuro.int16Array.fill
  • neuro.int16Array.filter
  • neuro.int16Array.find
  • neuro.int16Array.findIndex
  • neuro.int16Array.findLast
  • neuro.int16Array.findLastIndex
  • neuro.int16Array.forEach
  • neuro.int16Array.from
  • neuro.int16Array.includes
  • neuro.int16Array.indexOf
  • neuro.int16Array.join
  • neuro.int16Array.keys
  • neuro.int16Array.lastIndexOf
  • neuro.int16Array.map
  • neuro.int16Array.of
  • neuro.int16Array.reduce
  • neuro.int16Array.reduceRight
  • neuro.int16Array.reverse
  • neuro.int16Array.set
  • neuro.int16Array.slice
  • neuro.int16Array.some
  • neuro.int16Array.sort
  • neuro.int16Array.subarray
  • neuro.int16Array.toReversed
  • neuro.int16Array.toSorted
  • neuro.int16Array.values
  • neuro.int16Array.with

int32Array (31)

  • neuro.int32Array.at
  • neuro.int32Array.copyWithin
  • neuro.int32Array.entries
  • neuro.int32Array.every
  • neuro.int32Array.fill
  • neuro.int32Array.filter
  • neuro.int32Array.find
  • neuro.int32Array.findIndex
  • neuro.int32Array.findLast
  • neuro.int32Array.findLastIndex
  • neuro.int32Array.forEach
  • neuro.int32Array.from
  • neuro.int32Array.includes
  • neuro.int32Array.indexOf
  • neuro.int32Array.join
  • neuro.int32Array.keys
  • neuro.int32Array.lastIndexOf
  • neuro.int32Array.map
  • neuro.int32Array.of
  • neuro.int32Array.reduce
  • neuro.int32Array.reduceRight
  • neuro.int32Array.reverse
  • neuro.int32Array.set
  • neuro.int32Array.slice
  • neuro.int32Array.some
  • neuro.int32Array.sort
  • neuro.int32Array.subarray
  • neuro.int32Array.toReversed
  • neuro.int32Array.toSorted
  • neuro.int32Array.values
  • neuro.int32Array.with

int8Array (31)

  • neuro.int8Array.at
  • neuro.int8Array.copyWithin
  • neuro.int8Array.entries
  • neuro.int8Array.every
  • neuro.int8Array.fill
  • neuro.int8Array.filter
  • neuro.int8Array.find
  • neuro.int8Array.findIndex
  • neuro.int8Array.findLast
  • neuro.int8Array.findLastIndex
  • neuro.int8Array.forEach
  • neuro.int8Array.from
  • neuro.int8Array.includes
  • neuro.int8Array.indexOf
  • neuro.int8Array.join
  • neuro.int8Array.keys
  • neuro.int8Array.lastIndexOf
  • neuro.int8Array.map
  • neuro.int8Array.of
  • neuro.int8Array.reduce
  • neuro.int8Array.reduceRight
  • neuro.int8Array.reverse
  • neuro.int8Array.set
  • neuro.int8Array.slice
  • neuro.int8Array.some
  • neuro.int8Array.sort
  • neuro.int8Array.subarray
  • neuro.int8Array.toReversed
  • neuro.int8Array.toSorted
  • neuro.int8Array.values
  • neuro.int8Array.with

json (2)

  • neuro.json.parse
  • neuro.json.stringify

map (12)

  • neuro.map.clear
  • neuro.map.delete
  • neuro.map.entries
  • neuro.map.forEach
  • neuro.map.get
  • neuro.map.getOrInsert
  • neuro.map.getOrInsertComputed
  • neuro.map.groupBy
  • neuro.map.has
  • neuro.map.keys
  • neuro.map.set
  • neuro.map.values

math (36)

  • neuro.math.abs
  • neuro.math.acos
  • neuro.math.acosh
  • neuro.math.asin
  • neuro.math.asinh
  • neuro.math.atan
  • neuro.math.atan2
  • neuro.math.atanh
  • neuro.math.cbrt
  • neuro.math.ceil
  • neuro.math.clz32
  • neuro.math.cos
  • neuro.math.cosh
  • neuro.math.exp
  • neuro.math.expm1
  • neuro.math.f16round
  • neuro.math.floor
  • neuro.math.fround
  • neuro.math.hypot
  • neuro.math.imul
  • neuro.math.log
  • neuro.math.log10
  • neuro.math.log1p
  • neuro.math.log2
  • neuro.math.max
  • neuro.math.min
  • neuro.math.pow
  • neuro.math.random
  • neuro.math.round
  • neuro.math.sign
  • neuro.math.sin
  • neuro.math.sinh
  • neuro.math.sqrt
  • neuro.math.tan
  • neuro.math.tanh
  • neuro.math.trunc

number (9)

  • neuro.number.isFinite
  • neuro.number.isInteger
  • neuro.number.isNaN
  • neuro.number.isSafeInteger
  • neuro.number.parseFloat
  • neuro.number.parseInt
  • neuro.number.toExponential
  • neuro.number.toFixed
  • neuro.number.toPrecision

object (23)

  • neuro.object.assign
  • neuro.object.create
  • neuro.object.defineProperties
  • neuro.object.defineProperty
  • neuro.object.entries
  • neuro.object.freeze
  • neuro.object.fromEntries
  • neuro.object.getOwnPropertyDescriptor
  • neuro.object.getOwnPropertyDescriptors
  • neuro.object.getOwnPropertyNames
  • neuro.object.getOwnPropertySymbols
  • neuro.object.getPrototypeOf
  • neuro.object.groupBy
  • neuro.object.hasOwn
  • neuro.object.is
  • neuro.object.isExtensible
  • neuro.object.isFrozen
  • neuro.object.isSealed
  • neuro.object.keys
  • neuro.object.preventExtensions
  • neuro.object.seal
  • neuro.object.setPrototypeOf
  • neuro.object.values

promise (11)

  • neuro.promise.all
  • neuro.promise.allSettled
  • neuro.promise.any
  • neuro.promise.catch
  • neuro.promise.finally
  • neuro.promise.race
  • neuro.promise.reject
  • neuro.promise.resolve
  • neuro.promise.then
  • neuro.promise.try
  • neuro.promise.withResolvers

regExp (3)

  • neuro.regExp.compile
  • neuro.regExp.exec
  • neuro.regExp.test

set (15)

  • neuro.set.add
  • neuro.set.clear
  • neuro.set.delete
  • neuro.set.difference
  • neuro.set.entries
  • neuro.set.forEach
  • neuro.set.has
  • neuro.set.intersection
  • neuro.set.isDisjointFrom
  • neuro.set.isSubsetOf
  • neuro.set.isSupersetOf
  • neuro.set.keys
  • neuro.set.symmetricDifference
  • neuro.set.union
  • neuro.set.values

string (51)

  • neuro.string.anchor
  • neuro.string.at
  • neuro.string.big
  • neuro.string.blink
  • neuro.string.bold
  • neuro.string.charAt
  • neuro.string.charCodeAt
  • neuro.string.codePointAt
  • neuro.string.concat
  • neuro.string.endsWith
  • neuro.string.fixed
  • neuro.string.fontcolor
  • neuro.string.fontsize
  • neuro.string.fromCharCode
  • neuro.string.fromCodePoint
  • neuro.string.includes
  • neuro.string.indexOf
  • neuro.string.isWellFormed
  • neuro.string.italics
  • neuro.string.lastIndexOf
  • neuro.string.link
  • neuro.string.localeCompare
  • neuro.string.match
  • neuro.string.matchAll
  • neuro.string.normalize
  • neuro.string.padEnd
  • neuro.string.padStart
  • neuro.string.raw
  • neuro.string.repeat
  • neuro.string.replace
  • neuro.string.replaceAll
  • neuro.string.search
  • neuro.string.slice
  • neuro.string.small
  • neuro.string.split
  • neuro.string.startsWith
  • neuro.string.strike
  • neuro.string.sub
  • neuro.string.substr
  • neuro.string.substring
  • neuro.string.sup
  • neuro.string.toLocaleLowerCase
  • neuro.string.toLocaleUpperCase
  • neuro.string.toLowerCase
  • neuro.string.toUpperCase
  • neuro.string.toWellFormed
  • neuro.string.trim
  • neuro.string.trimEnd
  • neuro.string.trimLeft
  • neuro.string.trimRight
  • neuro.string.trimStart

symbol (2)

  • neuro.symbol.for
  • neuro.symbol.keyFor

uint16Array (31)

  • neuro.uint16Array.at
  • neuro.uint16Array.copyWithin
  • neuro.uint16Array.entries
  • neuro.uint16Array.every
  • neuro.uint16Array.fill
  • neuro.uint16Array.filter
  • neuro.uint16Array.find
  • neuro.uint16Array.findIndex
  • neuro.uint16Array.findLast
  • neuro.uint16Array.findLastIndex
  • neuro.uint16Array.forEach
  • neuro.uint16Array.from
  • neuro.uint16Array.includes
  • neuro.uint16Array.indexOf
  • neuro.uint16Array.join
  • neuro.uint16Array.keys
  • neuro.uint16Array.lastIndexOf
  • neuro.uint16Array.map
  • neuro.uint16Array.of
  • neuro.uint16Array.reduce
  • neuro.uint16Array.reduceRight
  • neuro.uint16Array.reverse
  • neuro.uint16Array.set
  • neuro.uint16Array.slice
  • neuro.uint16Array.some
  • neuro.uint16Array.sort
  • neuro.uint16Array.subarray
  • neuro.uint16Array.toReversed
  • neuro.uint16Array.toSorted
  • neuro.uint16Array.values
  • neuro.uint16Array.with

uint32Array (31)

  • neuro.uint32Array.at
  • neuro.uint32Array.copyWithin
  • neuro.uint32Array.entries
  • neuro.uint32Array.every
  • neuro.uint32Array.fill
  • neuro.uint32Array.filter
  • neuro.uint32Array.find
  • neuro.uint32Array.findIndex
  • neuro.uint32Array.findLast
  • neuro.uint32Array.findLastIndex
  • neuro.uint32Array.forEach
  • neuro.uint32Array.from
  • neuro.uint32Array.includes
  • neuro.uint32Array.indexOf
  • neuro.uint32Array.join
  • neuro.uint32Array.keys
  • neuro.uint32Array.lastIndexOf
  • neuro.uint32Array.map
  • neuro.uint32Array.of
  • neuro.uint32Array.reduce
  • neuro.uint32Array.reduceRight
  • neuro.uint32Array.reverse
  • neuro.uint32Array.set
  • neuro.uint32Array.slice
  • neuro.uint32Array.some
  • neuro.uint32Array.sort
  • neuro.uint32Array.subarray
  • neuro.uint32Array.toReversed
  • neuro.uint32Array.toSorted
  • neuro.uint32Array.values
  • neuro.uint32Array.with

uint8Array (37)

  • neuro.uint8Array.at
  • neuro.uint8Array.copyWithin
  • neuro.uint8Array.entries
  • neuro.uint8Array.every
  • neuro.uint8Array.fill
  • neuro.uint8Array.filter
  • neuro.uint8Array.find
  • neuro.uint8Array.findIndex
  • neuro.uint8Array.findLast
  • neuro.uint8Array.findLastIndex
  • neuro.uint8Array.forEach
  • neuro.uint8Array.from
  • neuro.uint8Array.fromBase64
  • neuro.uint8Array.fromHex
  • neuro.uint8Array.includes
  • neuro.uint8Array.indexOf
  • neuro.uint8Array.join
  • neuro.uint8Array.keys
  • neuro.uint8Array.lastIndexOf
  • neuro.uint8Array.map
  • neuro.uint8Array.of
  • neuro.uint8Array.reduce
  • neuro.uint8Array.reduceRight
  • neuro.uint8Array.reverse
  • neuro.uint8Array.set
  • neuro.uint8Array.setFromBase64
  • neuro.uint8Array.setFromHex
  • neuro.uint8Array.slice
  • neuro.uint8Array.some
  • neuro.uint8Array.sort
  • neuro.uint8Array.subarray
  • neuro.uint8Array.toBase64
  • neuro.uint8Array.toHex
  • neuro.uint8Array.toReversed
  • neuro.uint8Array.toSorted
  • neuro.uint8Array.values
  • neuro.uint8Array.with

uint8ClampedArray (31)

  • neuro.uint8ClampedArray.at
  • neuro.uint8ClampedArray.copyWithin
  • neuro.uint8ClampedArray.entries
  • neuro.uint8ClampedArray.every
  • neuro.uint8ClampedArray.fill
  • neuro.uint8ClampedArray.filter
  • neuro.uint8ClampedArray.find
  • neuro.uint8ClampedArray.findIndex
  • neuro.uint8ClampedArray.findLast
  • neuro.uint8ClampedArray.findLastIndex
  • neuro.uint8ClampedArray.forEach
  • neuro.uint8ClampedArray.from
  • neuro.uint8ClampedArray.includes
  • neuro.uint8ClampedArray.indexOf
  • neuro.uint8ClampedArray.join
  • neuro.uint8ClampedArray.keys
  • neuro.uint8ClampedArray.lastIndexOf
  • neuro.uint8ClampedArray.map
  • neuro.uint8ClampedArray.of
  • neuro.uint8ClampedArray.reduce
  • neuro.uint8ClampedArray.reduceRight
  • neuro.uint8ClampedArray.reverse
  • neuro.uint8ClampedArray.set
  • neuro.uint8ClampedArray.slice
  • neuro.uint8ClampedArray.some
  • neuro.uint8ClampedArray.sort
  • neuro.uint8ClampedArray.subarray
  • neuro.uint8ClampedArray.toReversed
  • neuro.uint8ClampedArray.toSorted
  • neuro.uint8ClampedArray.values
  • neuro.uint8ClampedArray.with

weakMap (6)

  • neuro.weakMap.delete
  • neuro.weakMap.get
  • neuro.weakMap.getOrInsert
  • neuro.weakMap.getOrInsertComputed
  • neuro.weakMap.has
  • neuro.weakMap.set

weakSet (3)

  • neuro.weakSet.add
  • neuro.weakSet.delete
  • neuro.weakSet.has
Generated promptMath.floor
You are simulating the JavaScript built-in `Math.floor`.
## Original signature(s)
  Overload 1: (x: number) => number
## JSDoc
Returns the greatest integer less than or equal to its numeric argument.

## How to respond
- Behave EXACTLY as the original `floor` would, but use the user's intent to choose any callback / comparator / transform logic that the original would normally accept as an argument.
- Strictly preserve the original return type and shape.
- Output ONLY the JSON-encoded return value of the function call.
- Do NOT include explanations, prose, comments, or markdown fences.
- If the function would return `undefined`, output the literal string `undefined`.
- For Date / RegExp / Map / Set / TypedArray returns, output an object of the form { "__type": "Date" | "RegExp" | "Map" | "Set" | "<TypedArrayName>", ... } so the SDK can rehydrate it.
Generated promptArray.prototype.filter
You are simulating the JavaScript built-in `Array.prototype.filter`.
## Original signature(s)
  Overload 1: (predicate?: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => S[]
  Overload 2: (predicate?: (value: T, index: number, array: T[]) => unknown, thisArg?: any) => T[]
## JSDoc
Returns the elements of an array that meet the condition specified in a callback function.

## How to respond
- Behave EXACTLY as the original `filter` would, but use the user's intent to choose any callback / comparator / transform logic that the original would normally accept as an argument.
- Strictly preserve the original return type and shape.
- Output ONLY the JSON-encoded return value of the function call.
- Do NOT include explanations, prose, comments, or markdown fences.
- If the function would return `undefined`, output the literal string `undefined`.
- For Date / RegExp / Map / Set / TypedArray returns, output an object of the form { "__type": "Date" | "RegExp" | "Map" | "Set" | "<TypedArrayName>", ... } so the SDK can rehydrate it.
Generated promptJSON.parse
You are simulating the JavaScript built-in `JSON.parse`.
## Original signature(s)
  Overload 1: (text: string, reviver?: (this: any, key: string, value: any) => any) => any
## JSDoc
Converts a JavaScript Object Notation (JSON) string into an object.

## How to respond
- Behave EXACTLY as the original `parse` would, but use the user's intent to choose any callback / comparator / transform logic that the original would normally accept as an argument.
- Strictly preserve the original return type and shape.
- Output ONLY the JSON-encoded return value of the function call.
- Do NOT include explanations, prose, comments, or markdown fences.
- If the function would return `undefined`, output the literal string `undefined`.
- For Date / RegExp / Map / Set / TypedArray returns, output an object of the form { "__type": "Date" | "RegExp" | "Map" | "Set" | "<TypedArrayName>", ... } so the SDK can rehydrate it.