SYMBOL INDEX (408 symbols across 38 files)

FILE: scripts/build.mjs
  function writeModuleTypeManifest (line 31) | function writeModuleTypeManifest(outDir, type) {

FILE: scripts/export-tests.ts
  function extractTests (line 11) | async function extractTests() {

FILE: src/Sandbox.ts
  class Sandbox (line 23) | class Sandbox extends SandboxExec {
    method constructor (line 24) | constructor(options?: IOptionParams) {
    method audit (line 28) | static audit<T>(code: string, scopes: IScope[] = []): ExecReturn<T> {
    method parse (line 47) | static parse(code: string) {
    method Function (line 51) | get Function() {
    method AsyncFunction (line 69) | get AsyncFunction() {
    method eval (line 87) | get eval() {
    method compile (line 105) | compile<T>(
    method compileAsync (line 122) | compileAsync<T>(
    method compileExpression (line 138) | compileExpression<T>(
    method compileExpressionAsync (line 151) | compileExpressionAsync<T>(

FILE: src/SandboxExec.ts
  function subscribeSet (line 16) | function subscribeSet(
  class SandboxExec (line 49) | class SandboxExec {
    method constructor (line 80) | constructor(
    method SAFE_GLOBALS (line 104) | static get SAFE_GLOBALS(): IGlobals {
    method SAFE_SYMBOLS (line 163) | static get SAFE_SYMBOLS(): ISymbolWhitelist {
    method SAFE_PROTOTYPES (line 182) | static get SAFE_PROTOTYPES(): Map<any, Set<string>> {
    method subscribeGet (line 236) | subscribeGet(
    method subscribeSet (line 244) | subscribeSet(
    method subscribeSetGlobal (line 253) | subscribeSetGlobal(
    method subscribeHalt (line 261) | subscribeHalt(cb: (context: HaltContext) => void) {
    method subscribeResume (line 269) | subscribeResume(cb: () => void) {
    method haltExecution (line 278) | haltExecution(haltContext: HaltContext = { type: 'manual' }) {
    method resumeExecution (line 286) | resumeExecution() {
    method getContext (line 300) | getContext(fn: (...args: any[]) => any) {
    method executeTree (line 304) | executeTree<T>(context: IExecContext, scopes: IScope[] = []): ExecRetu...
    method executeTreeAsync (line 308) | executeTreeAsync<T>(context: IExecContext, scopes: IScope[] = []): Pro...

FILE: src/eval/index.ts
  type IEvalContext (line 12) | interface IEvalContext {
  type SandboxFunction (line 25) | type SandboxFunction = (code: string, ...args: string[]) => () => unknown;
  type SandboxEval (line 26) | type SandboxEval = (code: string) => unknown;
  type SandboxSetTimeout (line 27) | type SandboxSetTimeout = (
  type SandboxSetInterval (line 32) | type SandboxSetInterval = (
  type SandboxClearTimeout (line 37) | type SandboxClearTimeout = (handle: number) => void;
  type SandboxClearInterval (line 38) | type SandboxClearInterval = (handle: number) => void;
  function createEvalContext (line 40) | function createEvalContext(): IEvalContext {
  function sandboxedSymbol (line 56) | function sandboxedSymbol(context: IExecContext) {
  function SB (line 60) | function SB() {}
  function sandboxFunction (line 61) | function sandboxFunction(context: IExecContext): SandboxFunction {
  type SandboxAsyncFunction (line 82) | type SandboxAsyncFunction = (code: string, ...args: string[]) => () => P...
  function SAF (line 83) | function SAF() {}
  function sandboxAsyncFunction (line 84) | function sandboxAsyncFunction(context: IExecContext): SandboxAsyncFuncti...
  type SandboxGeneratorFunction (line 105) | type SandboxGeneratorFunction = (
  function SGF (line 109) | function SGF() {}
  function sandboxGeneratorFunction (line 110) | function sandboxGeneratorFunction(context: IExecContext): SandboxGenerat...
  type SandboxAsyncGeneratorFunction (line 131) | type SandboxAsyncGeneratorFunction = (
  function SAGF (line 135) | function SAGF() {}
  function sandboxAsyncGeneratorFunction (line 136) | function sandboxAsyncGeneratorFunction(
  function SE (line 159) | function SE() {}
  function sandboxedEval (line 160) | function sandboxedEval(func: SandboxFunction, context: IExecContext): Sa...
  function wrapLastStatementInReturn (line 183) | function wrapLastStatementInReturn(tree: Lisp[]): Lisp[] {
  function sST (line 228) | function sST() {}
  function sandboxedSetTimeout (line 229) | function sandboxedSetTimeout(
  function sCT (line 274) | function sCT() {}
  function sandboxedClearTimeout (line 275) | function sandboxedClearTimeout(context: IExecContext): SandboxClearTimeo...
  function sCI (line 289) | function sCI() {}
  function sandboxedClearInterval (line 290) | function sandboxedClearInterval(context: IExecContext): SandboxClearInte...
  function sSI (line 306) | function sSI() {}
  function sandboxedSetInterval (line 307) | function sandboxedSetInterval(

FILE: src/executor/executorUtils.ts
  type Done (line 22) | type Done<T = any> = (err?: any, res?: T | typeof optional) => void;
  type ControlFlowAction (line 24) | type ControlFlowAction = 'break' | 'continue';
  type ControlFlowSignal (line 26) | interface ControlFlowSignal {
  type ControlFlowTarget (line 31) | interface ControlFlowTarget {
  type ControlFlowTargets (line 39) | type ControlFlowTargets = readonly ControlFlowTarget[] | undefined;
  class ExecReturn (line 41) | class ExecReturn<T> {
    method constructor (line 42) | constructor(
    method breakLoop (line 49) | get breakLoop() {
    method continueLoop (line 53) | get continueLoop() {
  type IChange (line 58) | interface IChange {
  type ICreate (line 62) | interface ICreate extends IChange {
  type IReplace (line 67) | interface IReplace extends IChange {
  type IDelete (line 71) | interface IDelete extends IChange {
  type IReverse (line 76) | interface IReverse extends IChange {
  type ISort (line 80) | interface ISort extends IChange {
  type IPush (line 84) | interface IPush extends IChange {
  type IPop (line 89) | interface IPop extends IChange {
  type IShift (line 94) | interface IShift extends IChange {
  type IUnShift (line 99) | interface IUnShift extends IChange {
  type ISplice (line 104) | interface ISplice extends IChange {
  type ICopyWithin (line 112) | interface ICopyWithin extends IChange {
  type Change (line 120) | type Change =
  function normalizeStatementLabel (line 135) | function normalizeStatementLabel(label: StatementLabel | undefined) {
  function normalizeStatementLabels (line 139) | function normalizeStatementLabels(label: LispItem | StatementLabel | und...
  function createLoopTarget (line 147) | function createLoopTarget(label?: string, acceptsUnlabeled = true): Cont...
  function createSwitchTarget (line 157) | function createSwitchTarget(label?: string): ControlFlowTarget {
  function createLabeledStatementTarget (line 167) | function createLabeledStatementTarget(label?: string): ControlFlowTarget...
  function addControlFlowTarget (line 178) | function addControlFlowTarget(
  function addControlFlowTargets (line 186) | function addControlFlowTargets(
  function matchesControlFlowTarget (line 196) | function matchesControlFlowTarget(signal: ControlFlowSignal, target: Con...
  function findControlFlowTarget (line 205) | function findControlFlowTarget(
  function generateArgs (line 227) | function generateArgs(argNames: string[], args: unknown[]) {
  function createFunction (line 239) | function createFunction(
  function createFunctionAsync (line 284) | function createFunctionAsync(
  class YieldValue (line 333) | class YieldValue {
    method constructor (line 334) | constructor(
  function asIterableIterator (line 344) | function asIterableIterator(value: unknown): Iterator<unknown> & Iterabl...
  function asAsyncIterableIterator (line 367) | function asAsyncIterableIterator(value: unknown): AsyncIterator<unknown>...
  function createGeneratorFunction (line 706) | function createGeneratorFunction(
  function createAsyncGeneratorFunction (line 769) | function createAsyncGeneratorFunction(
  function assignCheck (line 854) | function assignCheck(obj: Prop, context: IExecContext, op = 'assign') {
  class KeyVal (line 923) | class KeyVal {
    method constructor (line 924) | constructor(
  class SpreadObject (line 930) | class SpreadObject {
    method constructor (line 931) | constructor(public item: { [key: string]: unknown }) {}
  class SpreadArray (line 934) | class SpreadArray {
    method constructor (line 935) | constructor(public item: unknown[]) {}
  class ArrayHole (line 938) | class ArrayHole {}
  class If (line 940) | class If {
    method constructor (line 941) | constructor(
  function isPropertyKey (line 955) | function isPropertyKey(val: unknown): val is PropertyKey {
  function hasPossibleProperties (line 959) | function hasPossibleProperties(val: unknown): val is {} {
  function execMany (line 965) | function execMany(
  function _execManySync (line 992) | function _execManySync(
  function _execManyAsync (line 1020) | async function _execManyAsync(
  type AsyncDoneRet (line 1058) | interface AsyncDoneRet {
  function asyncDone (line 1064) | function asyncDone(callback: (done: Done) => void): AsyncDoneRet {
  function syncDone (line 1084) | function syncDone(callback: (done: Done) => void): { result: any } {
  function execAsync (line 1095) | async function execAsync<T = any>(
  function execSync (line 1210) | function execSync<T = any>(
  type OpsCallbackParams (line 1285) | type OpsCallbackParams<a, b, obj, bobj> = {
  function checkHaltExpectedTicks (line 1302) | function checkHaltExpectedTicks(
  function performOp (line 1346) | function performOp(params: OpsCallbackParams<any, any, any, any>, count ...
  function _execNoneRecurse (line 1395) | function _execNoneRecurse<T = any>(
  function executeTree (line 1546) | function executeTree<T>(
  function executeTreeAsync (line 1570) | async function executeTreeAsync<T>(
  function executeTreeWithDone (line 1597) | function executeTreeWithDone(
  function _executeWithDoneSync (line 1656) | function _executeWithDoneSync(
  function _executeWithDoneAsync (line 1705) | async function _executeWithDoneAsync(

FILE: src/executor/ops/call.ts
  function getNewTicks (line 183) | function getNewTicks(ctor: Function, args: unknown[]): bigint {

FILE: src/executor/opsRegistry.ts
  type ControlFlowAction (line 14) | type ControlFlowAction = 'break' | 'continue';
  type ControlFlowTarget (line 16) | interface ControlFlowTarget {
  type ControlFlowTargets (line 24) | type ControlFlowTargets = readonly ControlFlowTarget[] | undefined;
  type Execution (line 26) | type Execution = <T = any>(
  type OpsCallbackParams (line 37) | type OpsCallbackParams<a, b, obj, bobj> = {
  type OpCallback (line 54) | type OpCallback<a, b, obj, bobj> = (params: OpsCallbackParams<a, b, obj,...
  function addOps (line 58) | function addOps<a = unknown, b = unknown, obj = unknown, bobj = unknown>(

FILE: src/parser/lisp.ts
  type DefineLisp (line 3) | type DefineLisp<
  type ExtractLispOp (line 9) | type ExtractLispOp<L> = L extends DefineLisp<infer i, any, any> ? i : ne...
  type ExtractLispA (line 10) | type ExtractLispA<L> = L extends DefineLisp<any, infer i, any> ? i : never;
  type ExtractLispB (line 11) | type ExtractLispB<L> = L extends DefineLisp<any, any, infer i> ? i : never;
  type LispItemSingle (line 13) | type LispItemSingle = LispType.None | LispType.True | string | Lisp;
  type LispItem (line 14) | type LispItem = LispItemSingle | LispItemSingle[];
  type Lisp (line 15) | type Lisp = [LispType, LispItem, LispItem];
  type Literal (line 17) | type Literal = DefineLisp<LispType.Literal, string, Lisp[]> & { tempJsSt...
  type IfLisp (line 18) | type IfLisp = DefineLisp<LispType.If, Lisp, IfCase>;
  type InlineIf (line 19) | type InlineIf = DefineLisp<LispType.InlineIf, Lisp, InlineIfCase>;
  type StatementLabel (line 20) | type StatementLabel = string | LispType.None;
  type IfCase (line 21) | type IfCase = DefineLisp<LispType.IfCase, Lisp[], Lisp[]>;
  type InlineIfCase (line 22) | type InlineIfCase = DefineLisp<LispType.InlineIfCase, Lisp, Lisp>;
  type Labeled (line 23) | type Labeled = DefineLisp<LispType.Labeled, StatementLabel, Lisp>;
  type KeyValLisp (line 24) | type KeyValLisp = DefineLisp<LispType.KeyVal, string | Lisp, Lisp>;
  type SpreadObjectLisp (line 25) | type SpreadObjectLisp = DefineLisp<LispType.SpreadObject, LispType.None,...
  type SpreadArrayLisp (line 26) | type SpreadArrayLisp = DefineLisp<LispType.SpreadArray, LispType.None, L...
  type ArrayProp (line 27) | type ArrayProp = DefineLisp<LispType.ArrayProp, Lisp, Lisp>;
  type PropLisp (line 28) | type PropLisp = DefineLisp<LispType.Prop, Lisp, string | Lisp>;
  type PropOptional (line 29) | type PropOptional = DefineLisp<LispType.PropOptional, Lisp, Lisp[]>;
  type Call (line 30) | type Call = DefineLisp<LispType.Call, Lisp, Lisp[]>;
  type CallOptional (line 31) | type CallOptional = DefineLisp<LispType.CallOptional, Lisp, Lisp[]>;
  type CreateArray (line 32) | type CreateArray = DefineLisp<LispType.CreateArray, Lisp, Lisp[]>;
  type CreateObject (line 33) | type CreateObject = DefineLisp<LispType.CreateObject, Lisp, Lisp[]>;
  type Group (line 34) | type Group = DefineLisp<LispType.Group, Lisp, Lisp[]>;
  type Inverse (line 35) | type Inverse = DefineLisp<LispType.Inverse, Lisp, Lisp>;
  type Not (line 36) | type Not = DefineLisp<LispType.Not, Lisp, Lisp>;
  type Negative (line 37) | type Negative = DefineLisp<LispType.Negative, Lisp, Lisp>;
  type Positive (line 38) | type Positive = DefineLisp<LispType.Positive, Lisp, Lisp>;
  type Typeof (line 39) | type Typeof = DefineLisp<LispType.Typeof, Lisp, Lisp>;
  type Delete (line 40) | type Delete = DefineLisp<LispType.Delete, Lisp, Lisp>;
  type IncrementBefore (line 41) | type IncrementBefore = DefineLisp<LispType.IncrementBefore, Lisp, LispTy...
  type IncrementAfter (line 42) | type IncrementAfter = DefineLisp<LispType.IncrementAfter, Lisp, LispType...
  type DecrementBefore (line 43) | type DecrementBefore = DefineLisp<LispType.DecrementBefore, Lisp, LispTy...
  type DecrementAfter (line 44) | type DecrementAfter = DefineLisp<LispType.DecrementAfter, Lisp, LispType...
  type And (line 46) | type And = DefineLisp<LispType.And, Lisp, Lisp>;
  type Or (line 47) | type Or = DefineLisp<LispType.Or, Lisp, Lisp>;
  type NullishCoalescing (line 48) | type NullishCoalescing = DefineLisp<LispType.NullishCoalescing, Lisp, Li...
  type Instanceof (line 49) | type Instanceof = DefineLisp<LispType.Instanceof, Lisp, Lisp>;
  type In (line 50) | type In = DefineLisp<LispType.In, Lisp, Lisp>;
  type Assigns (line 51) | type Assigns = DefineLisp<LispType.Assign, Lisp, Lisp>;
  type SubractEquals (line 52) | type SubractEquals = DefineLisp<LispType.SubractEquals, Lisp, Lisp>;
  type AddEquals (line 53) | type AddEquals = DefineLisp<LispType.AddEquals, Lisp, Lisp>;
  type DivideEquals (line 54) | type DivideEquals = DefineLisp<LispType.DivideEquals, Lisp, Lisp>;
  type PowerEquals (line 55) | type PowerEquals = DefineLisp<LispType.PowerEquals, Lisp, Lisp>;
  type MultiplyEquals (line 56) | type MultiplyEquals = DefineLisp<LispType.MultiplyEquals, Lisp, Lisp>;
  type ModulusEquals (line 57) | type ModulusEquals = DefineLisp<LispType.ModulusEquals, Lisp, Lisp>;
  type BitNegateEquals (line 58) | type BitNegateEquals = DefineLisp<LispType.BitNegateEquals, Lisp, Lisp>;
  type BitAndEquals (line 59) | type BitAndEquals = DefineLisp<LispType.BitAndEquals, Lisp, Lisp>;
  type BitOrEquals (line 60) | type BitOrEquals = DefineLisp<LispType.BitOrEquals, Lisp, Lisp>;
  type UnsignedShiftRightEquals (line 61) | type UnsignedShiftRightEquals = DefineLisp<LispType.UnsignedShiftRightEq...
  type ShiftLeftEquals (line 62) | type ShiftLeftEquals = DefineLisp<LispType.ShiftLeftEquals, Lisp, Lisp>;
  type ShiftRightEquals (line 63) | type ShiftRightEquals = DefineLisp<LispType.ShiftRightEquals, Lisp, Lisp>;
  type AndEquals (line 64) | type AndEquals = DefineLisp<LispType.AndEquals, Lisp, Lisp>;
  type OrEquals (line 65) | type OrEquals = DefineLisp<LispType.OrEquals, Lisp, Lisp>;
  type NullishCoalescingEquals (line 66) | type NullishCoalescingEquals = DefineLisp<LispType.NullishCoalescingEqua...
  type BitAnd (line 68) | type BitAnd = DefineLisp<LispType.BitAnd, Lisp, Lisp>;
  type BitOr (line 69) | type BitOr = DefineLisp<LispType.BitOr, Lisp, Lisp>;
  type BitNegate (line 70) | type BitNegate = DefineLisp<LispType.BitNegate, Lisp, Lisp>;
  type BitShiftLeft (line 71) | type BitShiftLeft = DefineLisp<LispType.BitShiftLeft, Lisp, Lisp>;
  type BitShiftRight (line 72) | type BitShiftRight = DefineLisp<LispType.BitShiftRight, Lisp, Lisp>;
  type BitUnsignedShiftRight (line 73) | type BitUnsignedShiftRight = DefineLisp<LispType.BitUnsignedShiftRight, ...
  type SmallerEqualThan (line 74) | type SmallerEqualThan = DefineLisp<LispType.SmallerEqualThan, Lisp, Lisp>;
  type LargerEqualThan (line 75) | type LargerEqualThan = DefineLisp<LispType.LargerEqualThan, Lisp, Lisp>;
  type SmallerThan (line 76) | type SmallerThan = DefineLisp<LispType.SmallerThan, Lisp, Lisp>;
  type LargerThan (line 77) | type LargerThan = DefineLisp<LispType.LargerThan, Lisp, Lisp>;
  type StrictNotEqual (line 78) | type StrictNotEqual = DefineLisp<LispType.StrictNotEqual, Lisp, Lisp>;
  type NotEqual (line 79) | type NotEqual = DefineLisp<LispType.NotEqual, Lisp, Lisp>;
  type StrictEqual (line 80) | type StrictEqual = DefineLisp<LispType.StrictEqual, Lisp, Lisp>;
  type Equal (line 81) | type Equal = DefineLisp<LispType.Equal, Lisp, Lisp>;
  type Plus (line 82) | type Plus = DefineLisp<LispType.Plus, Lisp, Lisp>;
  type Minus (line 83) | type Minus = DefineLisp<LispType.Minus, Lisp, Lisp>;
  type Divide (line 84) | type Divide = DefineLisp<LispType.Divide, Lisp, Lisp>;
  type Power (line 85) | type Power = DefineLisp<LispType.Power, Lisp, Lisp>;
  type Multiply (line 86) | type Multiply = DefineLisp<LispType.Multiply, Lisp, Lisp>;
  type Modulus (line 87) | type Modulus = DefineLisp<LispType.Modulus, Lisp, Lisp>;
  type InternalCode (line 89) | type InternalCode = DefineLisp<LispType.InternalBlock, Lisp[], LispType....
  type Block (line 90) | type Block = DefineLisp<LispType.Block, Lisp[], LispType.None>;
  type Expression (line 91) | type Expression = DefineLisp<LispType.Expression, Lisp[], LispType.None>;
  type Return (line 92) | type Return = DefineLisp<LispType.Return, LispType.None, Lisp>;
  type Throw (line 93) | type Throw = DefineLisp<LispType.Throw, LispType.None, Lisp>;
  type Switch (line 94) | type Switch = DefineLisp<LispType.Switch, Lisp, SwitchCase[]>;
  type SwitchCase (line 95) | type SwitchCase = DefineLisp<LispType.SwitchCase, LispType.None | Lisp, ...
  type Var (line 96) | type Var = DefineLisp<LispType.Var, string, Lisp | LispType.None>;
  type Let (line 97) | type Let = DefineLisp<LispType.Let, string, Lisp | LispType.None>;
  type Const (line 98) | type Const = DefineLisp<LispType.Const, string, Lisp | LispType.None>;
  type Internal (line 99) | type Internal = DefineLisp<LispType.Internal, string, Lisp | LispType.No...
  type Number (line 101) | type Number = DefineLisp<LispType.Number, LispType.None, string>;
  type BigInt (line 102) | type BigInt = DefineLisp<LispType.BigInt, LispType.None, string>;
  type GlobalSymbol (line 103) | type GlobalSymbol = DefineLisp<LispType.GlobalSymbol, LispType.None, str...
  type LiteralIndex (line 104) | type LiteralIndex = DefineLisp<LispType.LiteralIndex, LispType.None, str...
  type StringIndex (line 105) | type StringIndex = DefineLisp<LispType.StringIndex, LispType.None, string>;
  type RegexIndex (line 106) | type RegexIndex = DefineLisp<LispType.RegexIndex, LispType.None, string>;
  type Function (line 108) | type Function = DefineLisp<
  type InlineFunction (line 113) | type InlineFunction = DefineLisp<LispType.InlineFunction, string[], stri...
  type ArrowFunction (line 114) | type ArrowFunction = DefineLisp<LispType.ArrowFunction, string[], string...
  type Loop (line 115) | type Loop = DefineLisp<LispType.Loop, LispItem, Lisp[]>;
  type LoopAction (line 116) | type LoopAction = DefineLisp<LispType.LoopAction, string, StatementLabel>;
  type Try (line 117) | type Try = DefineLisp<LispType.Try, Lisp[], LispItem>;
  type Void (line 119) | type Void = DefineLisp<LispType.Void, Lisp, LispType.None>;
  type Await (line 120) | type Await = DefineLisp<LispType.Await, Lisp, LispType.None>;
  type Yield (line 121) | type Yield = DefineLisp<LispType.Yield, Lisp, LispType.None>;
  type YieldDelegate (line 122) | type YieldDelegate = DefineLisp<LispType.YieldDelegate, Lisp, LispType.N...
  type New (line 123) | type New = DefineLisp<LispType.New, Lisp, Lisp[]>;
  type None (line 124) | type None = DefineLisp<LispType.None, LispType.None, LispType.None>;
  type LispFamily (line 126) | type LispFamily =
  type IRegEx (line 225) | interface IRegEx {
  type IConstants (line 231) | interface IConstants {
  type IExecutionTree (line 239) | interface IExecutionTree {
  type LispDepthCtx (line 244) | interface LispDepthCtx {
  type LispCallbackCtx (line 250) | interface LispCallbackCtx extends LispDepthCtx {
  type LispCallback (line 259) | type LispCallback<T> = (ctx: LispCallbackCtx & { type: T }) => any;

FILE: src/parser/lispTypes/conditionals.ts
  function registerConditionalLispTypes (line 5) | function registerConditionalLispTypes({

FILE: src/parser/lispTypes/control.ts
  function registerControlLispTypes (line 14) | function registerControlLispTypes({

FILE: src/parser/lispTypes/declarations.ts
  function registerDeclarationLispTypes (line 14) | function registerDeclarationLispTypes({

FILE: src/parser/lispTypes/index.ts
  function registerLispTypes (line 9) | function registerLispTypes(deps: RegisterLispTypesDeps) {

FILE: src/parser/lispTypes/operators.ts
  function registerOperatorLispTypes (line 67) | function registerOperatorLispTypes({

FILE: src/parser/lispTypes/shared.ts
  type RegisterLispTypesDeps (line 15) | interface RegisterLispTypesDeps {

FILE: src/parser/lispTypes/structures.ts
  function registerStructureLispTypes (line 19) | function registerStructureLispTypes({

FILE: src/parser/lispTypes/values.ts
  function registerValueLispTypes (line 18) | function registerValueLispTypes({

FILE: src/parser/parserUtils.ts
  type LispWithSource (line 26) | type LispWithSource = Lisp & { source?: string };
  function createLisp (line 28) | function createLisp<L extends Lisp>(obj: {
  function extractStatementLabels (line 40) | function extractStatementLabels(prefix = '') {
  function wrapLabeledStatement (line 44) | function wrapLabeledStatement<T extends Lisp>(labels: string[], statemen...
  class ParseError (line 58) | class ParseError extends Error {
    method constructor (line 59) | constructor(
  function testMultiple (line 221) | function testMultiple(str: string, tests: RegExp[]) {
  type restDetails (line 239) | interface restDetails {
  function restOfExp (line 247) | function restOfExp(
  function splitByCommasDestructure (line 477) | function splitByCommasDestructure(s: string): string[] {
  function findFirstAtTopLevel (line 496) | function findFirstAtTopLevel(s: string, ch: string): number {
  function findPatternEndIdx (line 507) | function findPatternEndIdx(s: string): number {
  function assertIdentifier (line 521) | function assertIdentifier(name: string): string {
  function expandDestructure (line 526) | function expandDestructure(keyword: string, patternStr: string, rhsStr: ...
  function getDestructurePatternSource (line 721) | function getDestructurePatternSource(tree: LispItem): string | null {
  function expandFunctionParamDestructure (line 733) | function expandFunctionParamDestructure(
  function lispify (line 775) | function lispify(
  function lispifyExpr (line 854) | function lispifyExpr(
  function lispifyReturnExpr (line 908) | function lispifyReturnExpr(constants: IConstants, str: CodeString) {
  function lispifyBlock (line 916) | function lispifyBlock(
  function lispifyFunction (line 970) | function lispifyFunction(
  function hoist (line 982) | function hoist(item: LispItem, res: Lisp[] = []): boolean {
  function insertSemicolons (line 1034) | function insertSemicolons(constants: IConstants, str: CodeString): CodeS...
  function checkRegex (line 1095) | function checkRegex(str: string): IRegEx | null {
  function extractConstants (line 1129) | function extractConstants(
  function parse (line 1247) | function parse(

FILE: src/utils/CodeString.ts
  class CodeString (line 1) | class CodeString {
    method constructor (line 5) | constructor(str: string | CodeString) {
    method substring (line 18) | substring(start: number, end?: number): CodeString {
    method length (line 40) | get length() {
    method char (line 45) | char(i: number) {
    method toString (line 50) | toString() {
    method trimStart (line 54) | trimStart() {
    method slice (line 63) | slice(start: number, end?: number) {
    method trim (line 83) | trim() {
    method valueOf (line 92) | valueOf() {

FILE: src/utils/ExecContext.ts
  class ExecContext (line 23) | class ExecContext implements IExecContext {
    method constructor (line 24) | constructor(
  function createSandboxSymbolContext (line 49) | function createSandboxSymbolContext(symbolWhitelist: ISymbolWhitelist): ...
  constant RESERVED_SYMBOL_PROPERTIES (line 57) | const RESERVED_SYMBOL_PROPERTIES = new Set(['length', 'name', 'prototype...
  function copyWhitelistedSymbols (line 59) | function copyWhitelistedSymbols(target: Function, symbolWhitelist: ISymb...
  function getSandboxSymbolCtor (line 69) | function getSandboxSymbolCtor(symbols: SandboxSymbolContext) {
  function SandboxGlobal (line 118) | function SandboxGlobal() {}
  type SandboxGlobalConstructor (line 119) | interface SandboxGlobalConstructor {
  function sandboxedGlobal (line 122) | function sandboxedGlobal(globals: ISandboxGlobal): SandboxGlobalConstruc...
  function createContext (line 132) | function createContext(sandbox: SandboxExec, options: IOptions): IContext {
  function createExecContext (line 161) | function createExecContext(
  function isLisp (line 237) | function isLisp<Type extends Lisp = Lisp>(item: LispItem | LispItem): it...

FILE: src/utils/Prop.ts
  class Prop (line 7) | class Prop<T = unknown> {
    method constructor (line 8) | constructor(
    method get (line 17) | get<T = unknown>(context: IExecContext): T {
  function hasOwnProperty (line 28) | function hasOwnProperty(obj: unknown, prop: PropertyKey): boolean {
  function getReplacementReceiver (line 32) | function getReplacementReceiver(fn: Function) {
  function resolveSandboxProp (line 36) | function resolveSandboxProp(val: unknown, context: IExecContext, prop?: ...
  function getReplacementValue (line 71) | function getReplacementValue(val: unknown, context: IExecContext, bindCo...
  function shouldBindReplacement (line 85) | function shouldBindReplacement(original: Function, bindContext: unknown,...
  function bindReplacement (line 95) | function bindReplacement(
  function redefineFunctionMetadata (line 123) | function redefineFunctionMetadata(

FILE: src/utils/Scope.ts
  function keysOnly (line 6) | function keysOnly(obj: unknown): Record<string, true> {
  type Unknown (line 14) | type Unknown = undefined | null | Record<string | number, unknown>;
  class Scope (line 16) | class Scope {
    method constructor (line 26) | constructor(parent: Scope | null, vars = {}, functionThis?: Unknown) {
    method get (line 36) | get(key: string, internal: boolean): Prop {
    method set (line 57) | set(key: string, val: unknown, internal: boolean) {
    method getWhereValScope (line 77) | getWhereValScope(key: string, isThis: boolean, internal: boolean): Sco...
    method getWhereVarScope (line 102) | getWhereVarScope(key: string, localScope: boolean, internal: boolean):...
    method declare (line 123) | declare(key: string, type: VarType, value: unknown, isGlobal: boolean,...
  class FunctionScope (line 165) | class FunctionScope implements IScope {}
  class LocalScope (line 167) | class LocalScope implements IScope {}
  class DelayedSynchronousResult (line 171) | class DelayedSynchronousResult {
    method constructor (line 173) | constructor(cb: () => unknown) {
  function delaySynchronousResult (line 178) | function delaySynchronousResult(cb: () => Promise<unknown>) {
  function sanitizeProp (line 182) | function sanitizeProp(
  function sanitizeScope (line 202) | function sanitizeScope(scope: IScope, context: IExecContext, cache = new...
  function sanitizeScopes (line 214) | function sanitizeScopes(

FILE: src/utils/errors.ts
  class SandboxError (line 3) | class SandboxError extends Error {}
  class SandboxExecutionQuotaExceededError (line 5) | class SandboxExecutionQuotaExceededError extends SandboxError {}
  class SandboxExecutionTreeError (line 7) | class SandboxExecutionTreeError extends SandboxError {}
  class SandboxCapabilityError (line 9) | class SandboxCapabilityError extends SandboxError {}
  class SandboxAccessError (line 11) | class SandboxAccessError extends SandboxError {}

FILE: src/utils/functionReplacements.ts
  function checkTicksAndThrow (line 8) | function checkTicksAndThrow(ctx: IExecContext, expectTicks: bigint): void {
  function isTypedArray (line 35) | function isTypedArray(obj: unknown): obj is { length: number } {
  type Factory (line 47) | type Factory = (ctx: IExecContext) => Function;
  function makeReplacement (line 49) | function makeReplacement(
  function arrayTicks (line 67) | function arrayTicks(
  function stringTicks (line 150) | function stringTicks(complexity: 'one' | 'n'): (thisArg: unknown, _args:...
  function mapTicks (line 211) | function mapTicks(complexity: 'one' | 'n'): (thisArg: unknown, _args: un...
  function setTicks (line 235) | function setTicks(complexity: 'one' | 'n'): (thisArg: unknown, _args: un...
  function typedArrayTicks (line 286) | function typedArrayTicks(
  function objectTicks (line 374) | function objectTicks(
  constant DEFAULT_FUNCTION_REPLACEMENTS (line 411) | const DEFAULT_FUNCTION_REPLACEMENTS = new Map<Function, Factory>();
  constant THIS_DEPENDENT_FUNCTION_REPLACEMENTS (line 412) | const THIS_DEPENDENT_FUNCTION_REPLACEMENTS = new Set<Function>();

FILE: src/utils/types.ts
  type IOptionParams (line 14) | interface IOptionParams {
  type IOptions (line 34) | interface IOptions {
  type IContext (line 51) | interface IContext {
  type IAuditReport (line 64) | interface IAuditReport {
  type Ticks (line 69) | interface Ticks {
  type SubscriptionSubject (line 75) | type SubscriptionSubject = object;
  type HaltContext (line 77) | type HaltContext =
  type IExecContext (line 100) | interface IExecContext extends IExecutionTree {
  type ISandboxGlobal (line 116) | interface ISandboxGlobal {
  type ISymbolWhitelist (line 120) | interface ISymbolWhitelist {
  type SandboxSymbolContext (line 124) | interface SandboxSymbolContext {
  type IGlobals (line 131) | type IGlobals = ISandboxGlobal;
  type IScope (line 133) | interface IScope {
  constant NON_BLOCKING_THRESHOLD (line 137) | const NON_BLOCKING_THRESHOLD = 50_000n;
  type VarType (line 181) | const enum VarType {
  type LispType (line 188) | const enum LispType {

FILE: src/utils/unraw.ts
  function parseHexToInt (line 9) | function parseHexToInt(hex: string): number {
  function validateAndParseHex (line 25) | function validateAndParseHex(hex: string, errorName: string, enforcedLen...
  function parseHexadecimalCode (line 41) | function parseHexadecimalCode(code: string): string {
  function parseUnicodeCode (line 56) | function parseUnicodeCode(code: string, surrogateCode?: string): string {
  function isCurlyBraced (line 72) | function isCurlyBraced(text: string): boolean {
  function parseUnicodeCodePointCode (line 84) | function parseUnicodeCodePointCode(codePoint: string): string {
  function parseSingleCharacterCode (line 117) | function parseSingleCharacterCode(code: string): string {
  function unraw (line 149) | function unraw(raw: string): string {

FILE: test/eval/reveseLinkedList.js
  function LinkedListNode (line 1) | function LinkedListNode(value) {
  function reverse (line 6) | function reverse(head) {
  function reverse (line 26) | function reverse(head) {

FILE: test/eval/script.js
  constant SANDBOX_HASH_KEY (line 13) | const SANDBOX_HASH_KEY = 'sandbox';
  constant SANDBOX_SETTINGS_HASH_KEY (line 14) | const SANDBOX_SETTINGS_HASH_KEY = 'settings';
  class TestError (line 584) | class TestError {
    method constructor (line 585) | constructor(error) { this.error = error; }
  method has (line 750) | has(target, key, context) {
  function renderPerf (line 890) | function renderPerf(cn, cs, en, es) {

FILE: test/eval/testCases/syntax-errors.data.ts
  function toEvalTest (line 4) | function toEvalTest(code: string, safeExpect: string): TestCase {

FILE: test/eval/testCases/test-utils.ts
  class TestError (line 9) | class TestError {
    method constructor (line 10) | constructor(public error: Error | null | undefined) {}
  function run (line 13) | async function run(test: TestCase, state: any, isAsync: boolean) {
  function getState (line 47) | function getState() {

FILE: test/eval/testCases/types.ts
  type TestCase (line 1) | interface TestCase {

FILE: test/symbol.spec.ts
  function createScope (line 4) | function createScope(vars: Record<string, unknown> = {}) {

FILE: test/ticks/sandboxArrayTicks.spec.ts
  function haltsWithQuota (line 4) | function haltsWithQuota(

FILE: test/ticks/sandboxCollectionTicks.spec.ts
  function haltsWithQuota (line 4) | function haltsWithQuota(
  function haltsWithQuota (line 89) | function haltsWithQuota(
  function FakeTypedArrayCtor (line 187) | function FakeTypedArrayCtor() {}
  function haltsWithQuota (line 195) | function haltsWithQuota(

FILE: test/ticks/sandboxNativeTicks.spec.ts
  function haltsWithQuota (line 4) | function haltsWithQuota(
  function haltsWithQuota (line 39) | function haltsWithQuota(
  function haltsWithQuota (line 69) | function haltsWithQuota(
  function haltsWithQuota (line 99) | function haltsWithQuota(
  function haltsWithQuota (line 135) | function haltsWithQuota(

FILE: test/ticks/sandboxObjectTicks.spec.ts
  function haltsWithQuota (line 4) | function haltsWithQuota(
  function haltsWithQuota (line 64) | function haltsWithQuota(
  function run (line 118) | function run(code: string, scope: Record<string, unknown> = {}) {

FILE: test/ticks/sandboxSpreadTicks.spec.ts
  function haltsWithQuota (line 4) | function haltsWithQuota(

FILE: test/ticks/sandboxStringTicks.spec.ts
  function haltsWithQuota (line 4) | function haltsWithQuota(
  function haltsWithQuota (line 84) | function haltsWithQuota(
  function haltsWithQuota (line 139) | function haltsWithQuota(
  function haltsWithQuota (line 184) | function haltsWithQuota(
  function haltsWithQuota (line 232) | function haltsWithQuota(