@nyariv/sandboxjs 0.8.23 → 0.8.25

package/dist/Sandbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"Sandbox.js","sources":["../src/unraw.ts","../src/parser.ts","../src/executor.ts","../src/Sandbox.ts"],"sourcesContent":["/**\n * Parse a string as a base-16 number. This is more strict than `parseInt` as it\n * will not allow any other characters, including (for example) \"+\", \"-\", and\n * \".\".\n * @param hex A string containing a hexadecimal number.\n * @returns The parsed integer, or `NaN` if the string is not a valid hex\n * number.\n */\nfunction parseHexToInt(hex: string): number {\n  const isOnlyHexChars = !hex.match(/[^a-f0-9]/i);\n  return isOnlyHexChars ? parseInt(hex, 16) : NaN;\n}\n\n/**\n * Check the validity and length of a hexadecimal code and optionally enforces\n * a specific number of hex digits.\n * @param hex The string to validate and parse.\n * @param errorName The name of the error message to throw a `SyntaxError` with\n * if `hex` is invalid. This is used to index `errorMessages`.\n * @param enforcedLength If provided, will throw an error if `hex` is not\n * exactly this many characters.\n * @returns The parsed hex number as a normal number.\n * @throws {SyntaxError} If the code is not valid.\n */\nfunction validateAndParseHex(\n  hex: string,\n  errorName: string,\n  enforcedLength?: number\n): number {\n  const parsedHex = parseHexToInt(hex);\n  if (\n    Number.isNaN(parsedHex) ||\n    (enforcedLength !== undefined && enforcedLength !== hex.length)\n  ) {\n    throw new SyntaxError(errorName + ': ' + hex);\n  }\n  return parsedHex;\n}\n\n/**\n * Parse a two-digit hexadecimal character escape code.\n * @param code The two-digit hexadecimal number that represents the character to\n * output.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the code is not valid hex or is not the right\n * length.\n */\nfunction parseHexadecimalCode(code: string): string {\n  const parsedCode = validateAndParseHex(\n    code,\n    'Malformed Hexadecimal',\n    2\n  );\n  return String.fromCharCode(parsedCode);\n}\n\n/**\n * Parse a four-digit Unicode character escape code.\n * @param code The four-digit unicode number that represents the character to\n * output.\n * @param surrogateCode Optional four-digit unicode surrogate that represents\n * the other half of the character to output.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the codes are not valid hex or are not the right\n * length.\n */\nfunction parseUnicodeCode(code: string, surrogateCode?: string): string {\n  const parsedCode = validateAndParseHex(code, 'Malformed Unicode', 4);\n\n  if (surrogateCode !== undefined) {\n    const parsedSurrogateCode = validateAndParseHex(\n      surrogateCode,\n      'Malformed Unicode',\n      4\n    );\n    return String.fromCharCode(parsedCode, parsedSurrogateCode);\n  }\n\n  return String.fromCharCode(parsedCode);\n}\n\n/**\n * Test if the text is surrounded by curly braces (`{}`).\n * @param text Text to check.\n * @returns `true` if the text is in the form `{*}`.\n */\nfunction isCurlyBraced(text: string): boolean {\n  return text.charAt(0) === \"{\" && text.charAt(text.length - 1) === \"}\";\n}\n\n/**\n * Parse a Unicode code point character escape code.\n * @param codePoint A unicode escape code point, including the surrounding curly\n * braces.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the code is not valid hex or does not have the\n * surrounding curly braces.\n */\nfunction parseUnicodeCodePointCode(codePoint: string): string {\n  if (!isCurlyBraced(codePoint)) {\n    throw new SyntaxError('Malformed Unicode: +' + codePoint);\n  }\n  const withoutBraces = codePoint.slice(1, -1);\n  const parsedCode = validateAndParseHex(\n    withoutBraces,\n    'Malformed Unicode'\n  );\n\n  try {\n    return String.fromCodePoint(parsedCode);\n  } catch (err) {\n    throw err instanceof RangeError\n      ? new SyntaxError('Code Point Limit:' + parsedCode)\n      : err;\n  }\n}\n\n/**\n * Map of unescaped letters to their corresponding special JS escape characters.\n * Intentionally does not include characters that map to themselves like \"\\'\".\n */\nconst singleCharacterEscapes = new Map<string, string>([\n  [\"b\", \"\\b\"],\n  [\"f\", \"\\f\"],\n  [\"n\", \"\\n\"],\n  [\"r\", \"\\r\"],\n  [\"t\", \"\\t\"],\n  [\"v\", \"\\v\"],\n  [\"0\", \"\\0\"]\n]);\n\n/**\n * Parse a single character escape sequence and return the matching character.\n * If none is matched, defaults to `code`.\n * @param code A single character code.\n */\nfunction parseSingleCharacterCode(code: string): string {\n  return singleCharacterEscapes.get(code) || code;\n}\n\n/**\n * Matches every escape sequence possible, including invalid ones.\n *\n * All capture groups (described below) are unique (only one will match), except\n * for 4, which can only potentially match if 3 does.\n *\n * **Capture Groups:**\n * 0. A single backslash\n * 1. Hexadecimal code\n * 2. Unicode code point code with surrounding curly braces\n * 3. Unicode escape code with surrogate\n * 4. Surrogate code\n * 5. Unicode escape code without surrogate\n * 6. Octal code _NOTE: includes \"0\"._\n * 7. A single character (will never be \\, x, u, or 0-3)\n */\nconst escapeMatch = /\\\\(?:(\\\\)|x([\\s\\S]{0,2})|u(\\{[^}]*\\}?)|u([\\s\\S]{4})\\\\u([^{][\\s\\S]{0,3})|u([\\s\\S]{0,4})|([0-3]?[0-7]{1,2})|([\\s\\S])|$)/g;\n\n/**\n * Replace raw escape character strings with their escape characters.\n * @param raw A string where escape characters are represented as raw string\n * values like `\\'` rather than `'`.\n * @param allowOctals If `true`, will process the now-deprecated octal escape\n * sequences (ie, `\\111`).\n * @returns The processed string, with escape characters replaced by their\n * respective actual Unicode characters.\n */\nexport function unraw(raw: string): string {\n  return raw.replace(escapeMatch, function(\n    _,\n    backslash?: string,\n    hex?: string,\n    codePoint?: string,\n    unicodeWithSurrogate?: string,\n    surrogate?: string,\n    unicode?: string,\n    octal?: string,\n    singleCharacter?: string\n  ): string {\n    // Compare groups to undefined because empty strings mean different errors\n    // Otherwise, `\\u` would fail the same as `\\` which is wrong.\n    if (backslash !== undefined) {\n      return \"\\\\\";\n    }\n    if (hex !== undefined) {\n      return parseHexadecimalCode(hex);\n    }\n    if (codePoint !== undefined) {\n      return parseUnicodeCodePointCode(codePoint);\n    }\n    if (unicodeWithSurrogate !== undefined) {\n      return parseUnicodeCode(unicodeWithSurrogate, surrogate);\n    }\n    if (unicode !== undefined) {\n      return parseUnicodeCode(unicode);\n    }\n    if (octal === \"0\") {\n      return \"\\0\";\n    }\n    if (octal !== undefined) {\n      throw new SyntaxError('Octal Deprecation: ' + octal);\n    }\n    if (singleCharacter !== undefined) {\n      return parseSingleCharacterCode(singleCharacter);\n    }\n    throw new SyntaxError('End of string');\n  });\n}\nexport default unraw;","import unraw from \"./unraw.js\";\n\nexport const enum LispType {\n  None,\n  Prop,\n  StringIndex,\n  Let,\n  Const,\n  Call,\n  KeyVal,\n  Number,\n  Return,\n  Assign,\n  InlineFunction,\n  ArrowFunction,\n  CreateArray,\n  If,\n  IfCase,\n  InlineIf,\n  InlineIfCase,\n  SpreadObject,\n  SpreadArray,\n  ArrayProp,\n  PropOptional,\n  CallOptional,\n  CreateObject,\n  Group,\n  Not,\n  IncrementBefore,\n  IncrementAfter,\n  DecrementBefore,\n  DecrementAfter,\n  And,\n  Or,\n  StrictNotEqual,\n  StrictEqual,\n  Plus,\n  Var,\n  GlobalSymbol,\n  Literal,\n  Function,\n  Loop,\n  Try,\n  Switch,\n  SwitchCase,\n  Block,\n  Expression,\n  Await,\n  New,\n  Throw,\n  Minus,\n  Divide,\n  Power,\n  Multiply,\n  Modulus,\n  Equal,\n  NotEqual,\n  SmallerEqualThan,\n  LargerEqualThan,\n  SmallerThan,\n  LargerThan,\n  Negative,\n  Positive,\n  Typeof,\n  Delete,\n  Instanceof,\n  In,\n  Inverse,\n  SubractEquals,\n  AddEquals,\n  DivideEquals,\n  PowerEquals,\n  MultiplyEquals,\n  ModulusEquals,\n  BitNegateEquals,\n  BitAndEquals,\n  BitOrEquals,\n  UnsignedShiftRightEquals,\n  ShiftRightEquals,\n  ShiftLeftEquals,\n  BitAnd,\n  BitOr,\n  BitNegate,\n  BitShiftLeft,\n  BitShiftRight,\n  BitUnsignedShiftRight,\n  BigInt,\n  LiteralIndex,\n  RegexIndex,\n  LoopAction,\n  Void,\n  True,\n}\n\nexport type DefineLisp<op extends LispType, a extends LispItem|LispItem, b extends LispItem|LispItem> = [op, a, b];\n\nexport type ExtractLispOp<L> = L extends DefineLisp<infer i, any, any> ? i : never;\nexport type ExtractLispA<L> = L extends DefineLisp<any, infer i, any> ? i : never;\nexport type ExtractLispB<L> = L extends DefineLisp<any, any, infer i> ? i : never;\n\nexport type LispItemSingle = LispType.None|LispType.True|string|Lisp;\nexport type LispItem = LispItemSingle|LispItemSingle[];\nexport type Lisp = [LispType, LispItem, LispItem];\n\nfunction createLisp<L extends Lisp>(obj: {op: ExtractLispOp<L>, a: ExtractLispA<L>, b: ExtractLispB<L>}) {\n  return [obj.op, obj.a, obj.b] as L;\n}\n\nexport type Literal = DefineLisp<LispType.Literal, string, Lisp[]> & {tempJsStrings?: string[]}\nexport type If = DefineLisp<LispType.If, Lisp, IfCase>\nexport type InlineIf = DefineLisp<LispType.InlineIf, Lisp, InlineIfCase>\nexport type IfCase = DefineLisp<LispType.IfCase, Lisp[], Lisp[]>\nexport type InlineIfCase = DefineLisp<LispType.InlineIfCase, Lisp, Lisp>\nexport type KeyVal = DefineLisp<LispType.KeyVal, string|Lisp, Lisp[]>\nexport type SpreadObject = DefineLisp<LispType.SpreadObject, LispType.None, Lisp>;\nexport type SpreadArray = DefineLisp<LispType.SpreadArray, LispType.None, Lisp>;\nexport type ArrayProp = DefineLisp<LispType.ArrayProp, Lisp, Lisp>;\nexport type Prop = DefineLisp<LispType.Prop, Lisp, string|Lisp>;\nexport type PropOptional = DefineLisp<LispType.PropOptional, Lisp, Lisp[]>;\nexport type Call = DefineLisp<LispType.Call, Lisp, Lisp[]>;\nexport type CallOptional = DefineLisp<LispType.CallOptional, Lisp, Lisp[]>;\nexport type CreateArray = DefineLisp<LispType.CreateArray, Lisp, Lisp[]>;\nexport type CreateObject = DefineLisp<LispType.CreateObject, Lisp, Lisp[]>;\nexport type Group = DefineLisp<LispType.Group, Lisp, Lisp[]>;\nexport type Inverse = DefineLisp<LispType.Inverse, Lisp, Lisp>;\nexport type Not = DefineLisp<LispType.Not, Lisp, Lisp>;\nexport type Negative = DefineLisp<LispType.Negative, Lisp, Lisp>;\nexport type Positive = DefineLisp<LispType.Positive, Lisp, Lisp>;\nexport type Typeof = DefineLisp<LispType.Typeof, Lisp, Lisp>;\nexport type Delete = DefineLisp<LispType.Delete, Lisp, Lisp>;\nexport type IncrementBefore = DefineLisp<LispType.IncrementBefore, Lisp, LispType.None>;\nexport type IncrementAfter = DefineLisp<LispType.IncrementAfter, Lisp, LispType.None>;\nexport type DecrementBefore = DefineLisp<LispType.DecrementBefore, Lisp, LispType.None>;\nexport type DecrementAfter = DefineLisp<LispType.DecrementAfter, Lisp, LispType.None>;\n\nexport type And = DefineLisp<LispType.And, Lisp, Lisp>;\nexport type Or = DefineLisp<LispType.Or, Lisp, Lisp>;\nexport type Instanceof = DefineLisp<LispType.Instanceof, Lisp, Lisp>;\nexport type In = DefineLisp<LispType.In, Lisp, Lisp>;\nexport type Assigns = DefineLisp<LispType.Assign, Lisp, Lisp>;\nexport type SubractEquals = DefineLisp<LispType.SubractEquals, Lisp, Lisp>;\nexport type AddEquals = DefineLisp<LispType.AddEquals, Lisp, Lisp>;\nexport type DivideEquals = DefineLisp<LispType.DivideEquals, Lisp, Lisp>;\nexport type PowerEquals = DefineLisp<LispType.PowerEquals, Lisp, Lisp>;\nexport type MultiplyEquals = DefineLisp<LispType.MultiplyEquals, Lisp, Lisp>;\nexport type ModulusEquals = DefineLisp<LispType.ModulusEquals, Lisp, Lisp>;\nexport type BitNegateEquals = DefineLisp<LispType.BitNegateEquals, Lisp, Lisp>;\nexport type BitAndEquals = DefineLisp<LispType.BitAndEquals, Lisp, Lisp>;\nexport type BitOrEquals = DefineLisp<LispType.BitOrEquals, Lisp, Lisp>;\nexport type UnsignedShiftRightEquals = DefineLisp<LispType.UnsignedShiftRightEquals, Lisp, Lisp>;\nexport type ShiftLeftEquals = DefineLisp<LispType.ShiftLeftEquals, Lisp, Lisp>;\nexport type ShiftRightEquals = DefineLisp<LispType.ShiftRightEquals, Lisp, Lisp>;\n\nexport type BitAnd = DefineLisp<LispType.BitAnd, Lisp, Lisp>;\nexport type BitOr = DefineLisp<LispType.BitOr, Lisp, Lisp>;\nexport type BitNegate = DefineLisp<LispType.BitNegate, Lisp, Lisp>;\nexport type BitShiftLeft = DefineLisp<LispType.BitShiftLeft, Lisp, Lisp>;\nexport type BitShiftRight = DefineLisp<LispType.BitShiftRight, Lisp, Lisp>;\nexport type BitUnsignedShiftRight = DefineLisp<LispType.BitUnsignedShiftRight, Lisp, Lisp>;\nexport type SmallerEqualThan = DefineLisp<LispType.SmallerEqualThan, Lisp, Lisp>;\nexport type LargerEqualThan = DefineLisp<LispType.LargerEqualThan, Lisp, Lisp>;\nexport type SmallerThan = DefineLisp<LispType.SmallerThan, Lisp, Lisp>;\nexport type LargerThan = DefineLisp<LispType.LargerThan, Lisp, Lisp>;\nexport type StrictNotEqual = DefineLisp<LispType.StrictNotEqual, Lisp, Lisp>;\nexport type NotEqual = DefineLisp<LispType.NotEqual, Lisp, Lisp>;\nexport type StrictEqual = DefineLisp<LispType.StrictEqual, Lisp, Lisp>;\nexport type Equal = DefineLisp<LispType.Equal, Lisp, Lisp>;\nexport type Plus = DefineLisp<LispType.Plus, Lisp, Lisp>;\nexport type Minus = DefineLisp<LispType.Minus, Lisp, Lisp>;\nexport type Divide = DefineLisp<LispType.Divide, Lisp, Lisp>;\nexport type Power = DefineLisp<LispType.Power, Lisp, Lisp>;\nexport type Multiply = DefineLisp<LispType.Multiply, Lisp, Lisp>;\nexport type Modulus = DefineLisp<LispType.Modulus, Lisp, Lisp>;\n\nexport type Block = DefineLisp<LispType.Block, Lisp[], LispType.None>;\nexport type Expression = DefineLisp<LispType.Expression, Lisp[], LispType.None>;\nexport type Return = DefineLisp<LispType.Return, LispType.None, Lisp>;\nexport type Throw = DefineLisp<LispType.Throw, LispType.None, Lisp>;\nexport type Switch = DefineLisp<LispType.Switch, Lisp, SwitchCase[]>;\nexport type SwitchCase = DefineLisp<LispType.SwitchCase, LispType.None|Lisp, Lisp[]>;\nexport type Var = DefineLisp<LispType.Var, string, Lisp|LispType.None>;\nexport type Let = DefineLisp<LispType.Let, string, Lisp|LispType.None>;\nexport type Const = DefineLisp<LispType.Const, string, Lisp|LispType.None>;\n\nexport type Number = DefineLisp<LispType.Number, LispType.None, string>;\nexport type BigInt = DefineLisp<LispType.BigInt, LispType.None, string>;\nexport type GlobalSymbol = DefineLisp<LispType.GlobalSymbol, LispType.None, string>;\nexport type LiteralIndex = DefineLisp<LispType.LiteralIndex, LispType.None, string>;\nexport type StringIndex = DefineLisp<LispType.StringIndex, LispType.None, string>;\nexport type RegexIndex = DefineLisp<LispType.RegexIndex, LispType.None, string>;\n\nexport type Function = DefineLisp<LispType.Function, (string|LispType.None|LispType.True)[], string|Lisp[]>;\nexport type InlineFunction = DefineLisp<LispType.InlineFunction, string[], string|Lisp[]>;\nexport type ArrowFunction = DefineLisp<LispType.ArrowFunction, string[], string|Lisp[]>;\nexport type Loop = DefineLisp<LispType.Loop, LispItem, Lisp[]>;\nexport type LoopAction = DefineLisp<LispType.LoopAction, string, LispType.None>;\nexport type Try = DefineLisp<LispType.Try, Lisp[], LispItem>;\n\nexport type Void = DefineLisp<LispType.Void, Lisp, LispType.None>;\nexport type Await = DefineLisp<LispType.Await, Lisp, LispType.None>;\nexport type New = DefineLisp<LispType.New, Lisp, Lisp[]>;\nexport type None = DefineLisp<LispType.None, LispType.None, LispType.None>;\n\nexport type LispFamily = \n  Literal\n  |If\n  |InlineIf\n  |IfCase\n  |InlineIfCase\n  |KeyVal\n  |SpreadObject\n  |SpreadArray\n  |ArrayProp\n  |Prop\n  |PropOptional\n  |Call\n  |CallOptional\n  |CreateArray\n  |CreateObject\n  |Group\n  |Inverse\n  |Not\n  |Negative\n  |Positive\n  |Typeof\n  |Delete\n  |IncrementBefore\n  |IncrementAfter\n  |DecrementBefore\n  |DecrementAfter\n  |And\n  |Or\n  |Instanceof\n  |In\n  |Assigns\n  |SubractEquals\n  |AddEquals\n  |DivideEquals\n  |PowerEquals\n  |MultiplyEquals\n  |ModulusEquals\n  |BitNegateEquals\n  |BitAndEquals\n  |BitOrEquals\n  |UnsignedShiftRightEquals\n  |ShiftLeftEquals\n  |ShiftRightEquals\n  |BitAnd\n  |BitOr\n  |BitNegate\n  |BitShiftLeft\n  |BitShiftRight\n  |BitUnsignedShiftRight\n  |SmallerEqualThan\n  |LargerEqualThan\n  |SmallerThan\n  |LargerThan\n  |StrictNotEqual\n  |NotEqual\n  |StrictEqual\n  |Equal\n  |Plus\n  |Minus\n  |Divide\n  |Power\n  |Multiply\n  |Modulus\n  |Block\n  |Expression\n  |Return\n  |Throw\n  |Switch\n  |SwitchCase\n  |Var\n  |Let\n  |Const\n  |Number\n  |BigInt\n  |GlobalSymbol\n  |LiteralIndex\n  |StringIndex\n  |RegexIndex\n  |Function\n  |InlineFunction\n  |ArrowFunction\n  |Loop\n  |LoopAction\n  |Try\n  |Void\n  |Await\n  |New\n  |None;\n\nexport interface IRegEx {\n  regex: string,\n  flags: string,\n  length: number\n}\n\nexport interface IConstants {\n  strings: string[];\n  literals: Literal[];\n  regexes: IRegEx[];\n  eager: boolean;\n}\n\nexport interface IExecutionTree {\n  tree: Lisp[], \n  constants: IConstants\n}\n\ntype LispCallback<T> = (strings: IConstants, type: T, part: CodeString, res: string[], expect: string, ctx: {lispTree: Lisp}) => any\nlet lispTypes: Map<string, LispCallback<string>> = new Map();\n\nexport class ParseError extends Error {\n  constructor(message: string, public code: string) {\n    super(message + \": \" + code.substring(0, 40));\n  }\n}\n\nconst inlineIfElse =  /^:/;\nconst elseIf = /^else(?![\\w\\$])/\nconst ifElse = /^if(?![\\w\\$])/\nconst space = /^\\s/;\n\nexport let expectTypes = {\n  splitter: {\n    types: {\n      opHigh: /^(\\/|\\*\\*|\\*(?!\\*)|\\%)(?!\\=)/,\n      op: /^(\\+(?!(\\+))|\\-(?!(\\-)))(?!\\=)/,\n      comparitor: /^(<=|>=|<(?!<)|>(?!>)|!==|!=(?!\\=)|===|==)/,\n      boolOp: /^(&&|\\|\\||instanceof(?![\\w\\$])|in(?![\\w\\$]))/,\n      bitwise: /^(&(?!&)|\\|(?!\\|)|\\^|<<|>>(?!>)|>>>)(?!\\=)/,\n    },\n    next: [\n      'modifier',\n      'value', \n      'prop', \n      'incrementerBefore',\n    ]\n  },\n  inlineIf: {\n    types: {\n      inlineIf: /^\\?(?!\\.(?!\\d))/,\n    },\n    next: [\n      'expEnd'\n    ]\n  },\n  assignment: {\n    types: {\n      assignModify: /^(\\-=|\\+=|\\/=|\\*\\*=|\\*=|%=|\\^=|\\&=|\\|=|>>>=|>>=|<<=)/,\n      assign: /^(=)(?!=)/\n    },\n    next: [\n      'modifier',\n      'value', \n      'prop', \n      'incrementerBefore',\n    ]\n  },\n  incrementerBefore: {\n    types: {incrementerBefore: /^(\\+\\+|\\-\\-)/},\n    next: [\n      'prop',\n    ]\n  },\n  expEdge: {\n    types: {\n      call: /^(\\?\\.)?[\\(]/,\n      incrementerAfter: /^(\\+\\+|\\-\\-)/\n    },\n    next: [\n      'splitter',\n      'expEdge',\n      'dot',\n      'inlineIf',\n      'expEnd'\n    ]\n  },\n  modifier: {\n    types: {\n      not: /^!/,\n      inverse: /^~/,\n      negative: /^\\-(?!\\-)/,\n      positive: /^\\+(?!\\+)/,\n      typeof: /^typeof(?![\\w\\$])/,\n      delete: /^delete(?![\\w\\$])/,\n    },\n    next: [\n      'modifier', \n      'value',\n      'prop',\n      'incrementerBefore',\n    ]\n  },\n  dot: {\n    types: {\n      arrayProp: /^(\\?\\.)?\\[/,\n      dot: /^(\\?)?\\.(?=\\s*[a-zA-Z\\$\\_])/,\n    },\n    next: [\n      'splitter',\n      'assignment',\n      'expEdge',\n      'dot',\n      'inlineIf',\n      'expEnd'\n    ]\n  },\n  prop: {\n    types: {\n      prop: /^[a-zA-Z\\$\\_][a-zA-Z\\d\\$\\_]*/,\n    },\n    next: [\n      'splitter',\n      'assignment',\n      'expEdge',\n      'dot',\n      'inlineIf',\n      'expEnd'\n    ]\n  },\n  value: {\n    types: {\n      createObject: /^\\{/,\n      createArray: /^\\[/,\n      number: /^(0x[\\da-f]+(_[\\da-f]+)*|(\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?|\\.\\d+(_\\d+)*))(e[\\+\\-]?\\d+(_\\d+)*)?(n)?(?!\\d)/i,\n      string: /^\"(\\d+)\"/,\n      literal: /^`(\\d+)`/,\n      regex: /^\\/(\\d+)\\/r(?![\\w\\$])/,\n      boolean: /^(true|false)(?![\\w\\$])/,\n      null: /^null(?![\\w\\$])/,\n      und: /^undefined(?![\\w\\$])/,\n      arrowFunctionSingle: /^(async\\s+)?([a-zA-Z\\$_][a-zA-Z\\d\\$_]*)\\s*=>\\s*({)?/,\n      arrowFunction: /^(async\\s*)?\\(\\s*((\\.\\.\\.)?\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*(\\s*,\\s*(\\.\\.\\.)?\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*)*)?\\s*\\)\\s*=>\\s*({)?/,\n      inlineFunction: /^(async\\s+)?function(\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*)?\\s*\\(\\s*((\\.\\.\\.)?\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*(\\s*,\\s*(\\.\\.\\.)?\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*)*)?\\s*\\)\\s*{/,\n      group: /^\\(/,\n      NaN: /^NaN(?![\\w\\$])/,\n      Infinity: /^Infinity(?![\\w\\$])/,\n      void: /^void(?![\\w\\$])\\s*/,\n      await: /^await(?![\\w\\$])\\s*/,\n      new: /^new(?![\\w\\$])\\s*/,\n    },\n    next: [\n      'splitter',\n      'expEdge',\n      'dot',\n      'inlineIf',\n      'expEnd'\n    ]\n  },\n  initialize: {\n    types: {\n      initialize: /^(var|let|const)\\s+([a-zA-Z\\$_][a-zA-Z\\d\\$_]*)\\s*(=)?/,\n      return: /^return(?![\\w\\$])/,\n      throw: /^throw(?![\\w\\$])\\s*/\n    },\n    next: [\n      'modifier',\n      'value', \n      'prop', \n      'incrementerBefore',\n      'expEnd'\n    ]\n  },\n  spreadObject: {\n    types: {\n      spreadObject: /^\\.\\.\\./\n    },\n    next: [\n      'value',\n      'prop', \n    ]\n  },\n  spreadArray: {\n    types: {\n      spreadArray: /^\\.\\.\\./\n    },\n    next: [\n      'value', \n      'prop', \n    ]\n  },\n  expEnd: {types: {}, next: []},\n  expFunction: {\n    types: {\n      function: /^(async\\s+)?function(\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*)\\s*\\(\\s*((\\.\\.\\.)?\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*(\\s*,\\s*(\\.\\.\\.)?\\s*[a-zA-Z\\$_][a-zA-Z\\d\\$_]*)*)?\\s*\\)\\s*{/,\n    },\n    next: [\n      'expEdge',\n      'expEnd'\n    ]\n  },\n  expSingle: {\n    types: {\n      for: /^(([a-zA-Z\\$\\_][\\w\\$]*)\\s*:)?\\s*for\\s*\\(/,\n      do: /^(([a-zA-Z\\$\\_][\\w\\$]*)\\s*:)?\\s*do(?![\\w\\$])\\s*(\\{)?/,\n      while: /^(([a-zA-Z\\$\\_][\\w\\$]*)\\s*:)?\\s*while\\s*\\(/,\n      loopAction: /^(break|continue)(?![\\w\\$])\\s*([a-zA-Z\\$\\_][\\w\\$]*)?/,\n      if: /^((([a-zA-Z\\$\\_][\\w\\$]*)\\s*:)?\\s*)if\\s*\\(/,\n      try: /^try\\s*{/,\n      block: /^{/,\n      switch: /^(([a-zA-Z\\$\\_][\\w\\$]*)\\s*:)?\\s*switch\\s*\\(/,\n    },\n    next: [\n      'expEnd'\n    ]\n  }\n} as const;\n\nlet closings = {\n  \"(\": \")\",\n  \"[\": \"]\",\n  \"{\": \"}\",\n  \"'\": \"'\",\n  '\"': '\"',\n  \"`\": \"`\"\n}\n\nexport function testMultiple(str: string, tests: RegExp[]) {\n  let found: RegExpExecArray;\n  for (let i = 0; i < tests.length; i++) {\n    const test = tests[i];\n    found = test.exec(str);\n    if (found) break;\n  }\n  return found;\n}\n\nexport class CodeString {\n  \n  start: number;\n  end: number;\n  ref: {str: string};\n  constructor(str: string|CodeString) {\n    this.ref = {str: \"\"};\n    if (str instanceof CodeString) {\n      this.ref = str.ref;\n      this.start = str.start\n      this.end = str.end;\n    } else {\n      this.ref.str = str;\n      this.start = 0;\n      this.end = str.length;\n    }\n  }\n\n  substring(start: number, end?: number): CodeString {\n    if (!this.length) return this;\n    start = this.start + start;\n    if (start < 0) {\n      start = 0;\n    }\n    if (start > this.end) {\n      start = this.end;\n    }\n    end = end === undefined ? this.end : this.start + end;\n    if (end < 0) {\n      end = 0;\n    }\n    if (end > this.end) {\n      end = this.end;\n    }\n    const code = new CodeString(this);\n    code.start = start;\n    code.end = end;\n    return code;\n  }\n\n  get length () {\n    const len = this.end - this.start;\n    return len < 0 ? 0 : len;\n  }\n\n  char(i: number) {\n    if (this.start === this.end) return undefined;\n    return this.ref.str[this.start + i];\n  }\n\n  toString() {\n    return this.ref.str.substring(this.start, this.end);\n  }\n\n  trimStart() {\n    const found = /^\\s+/.exec(this.toString());\n    const code = new CodeString(this);\n    if (found) {\n      code.start += found[0].length;\n    }\n    return code;\n  }\n\n  slice(start: number, end?: number) {\n    if (start < 0) {\n      start = this.end - this.start + start;\n    }\n    if (start < 0) {\n      start = 0;\n    }\n    if (end === undefined) {\n      end = this.end - this.start;\n    }\n\n    if (end < 0) {\n      end = this.end - this.start + end;\n    }\n    if (end < 0) {\n      end = 0;\n    }\n    return this.substring(start, end);\n  }\n\n  trim() {\n    const code = this.trimStart();\n    const found = /\\s+$/.exec(code.toString());\n    if (found) {\n      code.end -= found[0].length;\n    }\n    return code;\n  }\n\n  valueOf() {\n    return this.toString();\n  }\n}\n\n\nconst emptyString = new CodeString(\"\")\n\nconst okFirstChars = /^[\\+\\-~ !]/;\nconst aChar = /^[\\w\\$]/\nconst aNumber = expectTypes.value.types.number;\nconst wordReg = /^((if|for|else|while|do|function)(?![\\w\\$])|[\\w\\$]+)/;\nconst semiColon = /^;/\nconst insertedSemicolons: WeakMap<{str: string}, Array<number>> = new WeakMap();\nconst quoteCache: WeakMap<{str: string}, Map<number, number>> = new WeakMap();\nexport interface restDetails {oneliner?: boolean, words?: string[], lastWord?: string, lastAnyWord?: string, regRes?: RegExpExecArray}\nexport function restOfExp(constants: IConstants, \n                          part: CodeString, \n                          tests?: RegExp[], \n                          quote?: string, \n                          firstOpening?: string, \n                          closingsTests?: RegExp[], \n                          details: restDetails = {}): CodeString {\n  if (!part.length) {\n    return part;\n  }\n  details.words = details.words || [];\n  let isStart = true;\n  tests = tests || [];\n  const hasSemiTest = tests.includes(semiColon);\n  if (hasSemiTest) {\n    tests = tests.filter((a) => a !== semiColon);\n  }\n  const insertedSemis = insertedSemicolons.get(part.ref) || [];\n  const cache = quoteCache.get(part.ref) || new Map<number, number>();\n  quoteCache.set(part.ref, cache);\n  if (quote && cache.has(part.start - 1)) {\n    return part.substring(0, cache.get(part.start - 1) - part.start);\n  }\n  let escape = false;\n  let done = false;\n  let lastChar = \"\";\n  let isOneLiner = false;\n  let i;\n  let lastInertedSemi = false;\n  for (i = 0; i < part.length && !done; i++) {\n    let char = part.char(i);\n    if (quote === '\"' || quote === \"'\" || quote === \"`\") {\n      if (quote === \"`\" && char === \"$\" && part.char(i+1) === \"{\" && !escape) {\n        let skip = restOfExp(constants, part.substring(i+2), [], \"{\");\n        i += skip.length + 2;\n      } else if (char === quote && !escape) {\n        return part.substring(0, i);\n      }\n      escape = !escape && char === \"\\\\\";\n    } else if (closings[char]) {\n      if (!lastInertedSemi && insertedSemis[i + part.start]) {\n        lastInertedSemi = true\n        if (hasSemiTest) {\n          break;\n        }\n        i--;\n        lastChar = ';';\n        continue;\n      }\n      if (isOneLiner && char === \"{\") {\n        isOneLiner = false;\n      }\n      if (char === firstOpening) {\n        done = true;\n        break;\n      } else {\n        let skip = restOfExp(constants, part.substring(i+1), [], char);\n        cache.set(skip.start - 1, skip.end);\n        i += skip.length + 1;\n        isStart = false;\n        if (closingsTests) {\n          let sub = part.substring(i);\n          let found: RegExpExecArray;\n          if (found = testMultiple(sub.toString(), closingsTests)) {\n            details.regRes = found;\n            done = true;\n          }\n        }\n      }\n    } else if (!quote) {\n      let sub = part.substring(i).toString();\n      let foundWord: RegExpExecArray;\n      let foundNumber: RegExpExecArray;\n      if (closingsTests) {\n        let found: RegExpExecArray;\n        if (found = testMultiple(sub, closingsTests)) {\n          details.regRes = found;\n          i++;\n          done = true;\n          break;\n        }\n      }\n      if (foundNumber = aNumber.exec(sub)) {\n        i += foundNumber[0].length - 1;\n        sub = part.substring(i).toString();\n      } else if (lastChar != char) {\n        let found: [string]|RegExpExecArray;\n        if (char === ';' || (insertedSemis[i + part.start] && !isStart && !lastInertedSemi)) {\n          if (hasSemiTest) {\n            found = [\";\"];\n          } else if (insertedSemis[i + part.start]) {\n            lastInertedSemi = true\n            i--;\n            lastChar = ';';\n            continue;\n          }\n          char = sub = ';';\n        } else {\n          lastInertedSemi = false;\n        }\n        if (!found) {\n          found = testMultiple(sub, tests);\n        }\n        if (found) {\n          done = true;\n        }\n        if (!done && (foundWord = wordReg.exec(sub))) {\n          isOneLiner = true;\n          if (foundWord[0].length > 1) {\n            details.words.push(foundWord[1]);\n            details.lastAnyWord = foundWord[1];\n            if (foundWord[2]) {\n              details.lastWord = foundWord[2];\n            }\n          }\n          if(foundWord[0].length > 2) {\n            i += foundWord[0].length - 2;\n          }\n        }\n      }\n      if (isStart) {\n        if (okFirstChars.test(sub)) {\n          done = false;\n        } else {\n          isStart = false;\n        }\n      }\n      if (done) break;\n    } else if(char === closings[quote]) {\n      return part.substring(0, i);\n    }\n    lastChar = char;\n  }\n  if (quote) {\n    throw new SyntaxError(\"Unclosed '\" + quote + \"'\");\n  }\n  if (details) {\n    details.oneliner = isOneLiner;\n  }\n  return part.substring(0, i);\n}\nrestOfExp.next = [\n  'splitter',\n  'expEnd',\n  'inlineIf'\n];\n\nconst startingExecpted = ['initialize', 'expSingle', 'expFunction', 'value', 'modifier', 'prop', 'incrementerBefore', 'expEnd'];\n\nexport const setLispType = <T extends readonly string[]>(types: T, fn: LispCallback<T[number]>) => {\n  types.forEach((type) => {\n    lispTypes.set(type, fn);\n  })\n}\n\nconst closingsCreate: {[type:string]: RegExp} = {\n  'createArray': /^\\]/,\n  'createObject': /^\\}/,\n  'group': /^\\)/,\n  'arrayProp': /^\\]/,\n  'call': /^\\)/\n}\n\nconst typesCreate = {\n  'createArray': LispType.CreateArray,\n  'createObject': LispType.CreateObject,\n  'group': LispType.Group,\n  'arrayProp': LispType.ArrayProp,\n  'call': LispType.Call,\n  'prop': LispType.Prop,\n  '?prop': LispType.PropOptional,\n  '?call': LispType.CallOptional,\n} as const\n\nsetLispType(['createArray', 'createObject', 'group', 'arrayProp','call'] as const, (constants, type, part, res, expect, ctx) => {\n  let extract = emptyString;\n  let arg: CodeString[] = [];\n  let end = false;\n  let i = res[0].length;\n  const start = i;\n  while (i < part.length && !end) {\n    extract = restOfExp(constants, part.substring(i), [\n      closingsCreate[type],\n      /^,/\n    ]);\n    i += extract.length;\n    if (extract.trim().length) {\n      arg.push(extract);\n    }\n    if (part.char(i) !== ',') {\n      end = true;\n    } else {\n      i++;\n    }\n  }\n  const next = ['value', 'modifier', 'prop', 'incrementerBefore', 'expEnd'];\n  let l: Lisp|Lisp[];\n\n  let funcFound: RegExpExecArray;\n  switch(type) {\n    case 'group':\n    case 'arrayProp':\n      l = lispifyExpr(constants, part.substring(start, i));\n      break;\n    case 'call':\n    case 'createArray':\n      // @TODO: support 'empty' values\n      l = arg.map((e) => lispify(constants, e, [...next, 'spreadArray']));\n      break;\n    case 'createObject':\n      l = arg.map((str) => {\n        str = str.trimStart();\n        let value;\n        let key: string|Lisp = '';\n        funcFound = expectTypes.expFunction.types.function.exec('function ' + str);\n        if (funcFound) {\n          key = funcFound[2].trimStart();\n          value = lispify(constants, new CodeString('function ' + str.toString().replace(key, \"\")));\n        } else {\n          let extract = restOfExp(constants, str, [/^:/]);\n          key = lispify(constants, extract, [...next, 'spreadObject']) as Prop;\n          if (key[0] === LispType.Prop) {\n            key = (key as Prop)[2];\n          }\n          value = lispify(constants, str.substring(extract.length + 1));\n        }\n        return createLisp<KeyVal>({\n          op: LispType.KeyVal,\n          a: key,\n          b: value\n        });\n      });\n      break;\n  }\n  let lisptype = (type === 'arrayProp' ? (res[1] ? LispType.PropOptional : LispType.Prop) : (type === 'call' ? (res[1] ? LispType.CallOptional : LispType.Call) : typesCreate[type])) as (typeof typesCreate)[keyof typeof typesCreate];\n  ctx.lispTree = lispify(constants, part.substring(i + 1), expectTypes[expect].next, createLisp<ArrayProp|Prop|Call|CreateObject|CreateArray|Group|PropOptional|CallOptional>({\n    op: lisptype, \n    a: ctx.lispTree, \n    b: l,\n  }));\n});\n\nconst modifierTypes = {\n  'inverse': LispType.Inverse,\n  'not': LispType.Not,\n  'positive': LispType.Positive,\n  'negative': LispType.Negative,\n  'typeof': LispType.Typeof,  \n  'delete': LispType.Delete\n} as const\n\nsetLispType(['inverse', 'not', 'negative', 'positive', 'typeof', 'delete'] as const, (constants, type, part, res, expect, ctx) => {\n  let extract = restOfExp(constants, part.substring(res[0].length), [/^([^\\s\\.\\?\\w\\$]|\\?[^\\.])/]);\n  ctx.lispTree = lispify(constants, part.substring(extract.length + res[0].length), restOfExp.next, createLisp<Inverse|Not|Negative|Positive|Typeof|Delete>({\n    op: modifierTypes[type],\n    a: ctx.lispTree, \n    b: lispify(constants, extract, expectTypes[expect].next), \n  }));\n});\n\nconst incrementTypes = {\n  '++$': LispType.IncrementBefore,\n  '--$': LispType.DecrementBefore,\n  '$++': LispType.IncrementAfter,\n  '$--': LispType.DecrementAfter\n} as const\n\nsetLispType(['incrementerBefore'] as const, (constants, type, part, res, expect, ctx) => {\n  let extract = restOfExp(constants, part.substring(2), [/^[^\\s\\.\\w\\$]/]);\n  ctx.lispTree = lispify(constants, part.substring(extract.length + 2), restOfExp.next, createLisp<IncrementBefore|DecrementBefore>({\n    op: incrementTypes[res[0] + \"$\"], \n    a: lispify(constants, extract, expectTypes[expect].next),\n    b: LispType.None\n  }));\n});\n\nsetLispType(['incrementerAfter'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp<IncrementAfter|DecrementAfter>({\n    op: incrementTypes[\"$\"  + res[0]], \n    a: ctx.lispTree, \n    b: LispType.None\n  }));\n});\n\nconst adderTypes = {\n  '&&': LispType.And,\n  '||': LispType.Or,\n  'instanceof': LispType.Instanceof,\n  'in': LispType.In,\n  '=': LispType.Assign,\n  '-=': LispType.SubractEquals,\n  '+=': LispType.AddEquals,\n  '/=': LispType.DivideEquals,\n  '**=': LispType.PowerEquals,\n  '*=': LispType.MultiplyEquals,\n  '%=': LispType.ModulusEquals,\n  '^=': LispType.BitNegateEquals,\n  '&=': LispType.BitAndEquals,\n  '|=': LispType.BitOrEquals,\n  '>>>=': LispType.UnsignedShiftRightEquals,\n  '<<=': LispType.ShiftLeftEquals,\n  '>>=': LispType.ShiftRightEquals,\n} as const;\n\nsetLispType(['assign', 'assignModify', 'boolOp'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = createLisp<And|Or|Instanceof|In|Assigns|SubractEquals|AddEquals|DivideEquals|PowerEquals|MultiplyEquals|ModulusEquals|BitNegateEquals|BitAndEquals|BitOrEquals|UnsignedShiftRightEquals|ShiftLeftEquals|ShiftRightEquals>({\n    op: adderTypes[res[0]], \n    a: ctx.lispTree,\n    b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)\n  });\n});\n\nconst opTypes = {\n  '&': LispType.BitAnd,\n  '|': LispType.BitOr,\n  '^': LispType.BitNegate,\n  '<<': LispType.BitShiftLeft,\n  '>>': LispType.BitShiftRight,\n  '>>>': LispType.BitUnsignedShiftRight,\n  '<=': LispType.SmallerEqualThan,\n  '>=': LispType.LargerEqualThan,\n  '<': LispType.SmallerThan,\n  '>': LispType.LargerThan,\n  '!==': LispType.StrictNotEqual,\n  '!=': LispType.NotEqual,\n  '===': LispType.StrictEqual,\n  '==': LispType.Equal,\n  '+': LispType.Plus,\n  '-': LispType.Minus,\n  '/': LispType.Divide,\n  '**': LispType.Power,\n  '*': LispType.Multiply,\n  '%': LispType.Modulus,\n} as const\n\nsetLispType(['opHigh', 'op', 'comparitor', 'bitwise'] as const, (constants, type, part, res, expect, ctx) => {\n  const next = [\n    expectTypes.inlineIf.types.inlineIf,\n    inlineIfElse\n  ];\n  switch (type) {\n    case 'opHigh':\n      next.push(expectTypes.splitter.types.opHigh);\n    case 'op':\n      next.push(expectTypes.splitter.types.op);\n    case 'comparitor':\n      next.push(expectTypes.splitter.types.comparitor);\n    case 'bitwise':\n      next.push(expectTypes.splitter.types.bitwise);\n      next.push(expectTypes.splitter.types.boolOp);\n  }\n  let extract = restOfExp(constants, part.substring(res[0].length), next);\n  ctx.lispTree = lispify(constants, part.substring(extract.length + res[0].length), restOfExp.next, createLisp<BitAnd|BitOr|BitNegate|BitShiftLeft|BitShiftRight|BitUnsignedShiftRight|SmallerEqualThan|LargerEqualThan|SmallerThan|LargerThan|StrictNotEqual|NotEqual|StrictEqual|Equal|Plus|Minus|Divide|Power|Multiply|Modulus>  ({\n    op: opTypes[res[0]],\n    a: ctx.lispTree, \n    b: lispify(constants, extract, expectTypes[expect].next), \n  }));\n});\n\nsetLispType(['inlineIf'] as const, (constants, type, part, res, expect, ctx) => {\n  let found = false;\n  let extract = part.substring(0, 0);\n  let quoteCount = 1;\n  while(!found && extract.length < part.length) {\n    extract.end = restOfExp(constants, part.substring(extract.length + 1), [\n      expectTypes.inlineIf.types.inlineIf,\n      inlineIfElse\n    ]).end;\n    if (part.char(extract.length) === '?') {\n      quoteCount++\n    } else {\n      quoteCount--\n    }\n    if (!quoteCount) {\n      found = true;\n    }\n  }\n  extract.start = part.start + 1;\n  ctx.lispTree = createLisp<InlineIf>({\n    op: LispType.InlineIf,\n    a: ctx.lispTree, \n    b: createLisp<InlineIfCase>({\n      op: LispType.InlineIfCase,\n      a: lispifyExpr(constants, extract),\n      b: lispifyExpr(constants, part.substring(res[0].length + extract.length + 1))\n    })\n  });\n});\n\n\nfunction extractIfElse(constants: IConstants, part: CodeString) {\n  let count = 0;\n  let found = part.substring(0, 0);\n  let foundElse = emptyString;\n  let foundTrue: CodeString;\n  let first = true;\n  let elseReg: RegExpExecArray;\n  let details: restDetails = {}\n  while((found = restOfExp(constants, part.substring(found.end - part.start), [elseIf, ifElse, semiColon], undefined, undefined , undefined, details)).length || first) {\n    first = false;\n    const f = part.substring(found.end - part.start).toString();\n    \n    if (f.startsWith(\"if\")) {\n      found.end++;\n      count++;\n    } else if (f.startsWith('else')) {\n      foundTrue = part.substring(0, found.end - part.start);\n      found.end++;\n      count--;\n      if (!count) {\n        found.end--;\n      }\n    } else if (elseReg = /^;?\\s*else(?![\\w\\$])/.exec(f)) {\n      foundTrue = part.substring(0, found.end - part.start);\n      found.end += elseReg[0].length - 1;\n      count--;\n      if (!count) {\n        found.end -= elseReg[0].length - 1;\n      }\n    } else {\n      foundTrue = foundElse.length ? foundTrue : part.substring(0, found.end - part.start);\n      break;\n    }\n    if (!count) {\n      let ie = extractIfElse(constants, part.substring(found.end - part.start + (/^;?\\s*else(?![\\w\\$])/.exec(f)?.[0].length)));\n      foundElse = ie.all;\n      break;\n    }\n    details = {};\n  }\n  foundTrue = foundTrue || part.substring(0, found.end - part.start);\n  return {all: part.substring(0, Math.max(foundTrue.end, foundElse.end) - part.start), true: foundTrue, false: foundElse};\n}\n\nsetLispType(['if'] as const, (constants, type, part, res, expect, ctx) => {\n  let condition = restOfExp(constants, part.substring(res[0].length), [], \"(\");\n  const ie = extractIfElse(constants, part.substring(res[1].length));\n  const isBlock = /^\\s*\\{/.exec(part.substring(res[0].length + condition.length + 1).toString());\n  const startTrue = res[0].length - res[1].length + condition.length + 1;\n  \n  let trueBlock = ie.true.substring(startTrue);\n  let elseBlock = ie.false;\n  \n  condition = condition.trim();\n  trueBlock = trueBlock.trim();\n  elseBlock = elseBlock.trim();\n\n  if (trueBlock.char(0) === \"{\") trueBlock = trueBlock.slice(1, -1);\n  if (elseBlock.char(0) === \"{\") elseBlock = elseBlock.slice(1, -1);\n  ctx.lispTree = createLisp<If>({\n    op: LispType.If,\n    a: lispifyExpr(constants, condition), \n    b: createLisp<IfCase>({\n      op: LispType.IfCase,\n      a: lispifyBlock(trueBlock, constants),\n      b: lispifyBlock(elseBlock, constants)\n    })\n  });\n});\n\nsetLispType(['switch'] as const, (constants, type, part, res, expect, ctx) => {\n  const test = restOfExp(constants, part.substring(res[0].length), [], \"(\");\n  let start = part.toString().indexOf(\"{\", res[0].length + test.length + 1);\n  if (start === -1) throw new SyntaxError(\"Invalid switch\");\n  let statement = insertSemicolons(constants, restOfExp(constants, part.substring(start + 1), [], \"{\"));\n  let caseFound: RegExpExecArray;\n  const caseTest = /^\\s*(case\\s|default)\\s*/;\n  let cases: SwitchCase[] = [];\n  let defaultFound = false;\n  while(caseFound = caseTest.exec(statement.toString())) {\n    if (caseFound[1] === 'default') {\n      if (defaultFound) throw new SyntaxError(\"Only one default switch case allowed\");\n      defaultFound = true;\n    }\n    let cond = restOfExp(constants, statement.substring(caseFound[0].length), [/^:/]);\n    let found = emptyString;\n    let i = start = caseFound[0].length + cond.length + 1;\n    let bracketFound = /^\\s*\\{/.exec(statement.substring(i).toString());\n    let exprs: Lisp[] = [];\n    if (bracketFound) {\n      i += bracketFound[0].length;\n      found = restOfExp(constants, statement.substring(i), [], \"{\");\n      i += found.length + 1;\n      exprs = lispifyBlock(found, constants);\n    } else {\n      let notEmpty = restOfExp(constants, statement.substring(i), [caseTest]);\n      if (!notEmpty.trim().length) {\n        exprs = [];\n        i += notEmpty.length;\n      } else {\n        while((found = restOfExp(constants, statement.substring(i), [semiColon])).length) {\n          i += found.length + (statement.char(i + found.length) === ';' ? 1 : 0);\n          if (caseTest.test(statement.substring(i).toString())) {\n            break;\n          }\n        }\n        exprs = lispifyBlock(statement.substring(start, found.end - statement.start), constants);\n      }\n    }\n    statement = statement.substring(i);\n    cases.push(createLisp<SwitchCase>({\n      op: LispType.SwitchCase,\n      a: caseFound[1] === \"default\" ? undefined : lispifyExpr(constants, cond),\n      b: exprs\n    }));\n  }\n  ctx.lispTree = createLisp<Switch>({\n    op: LispType.Switch,\n    a: lispifyExpr(constants, test),\n    b: cases\n  });\n});\n\nsetLispType(['dot', 'prop'] as const, (constants, type, part, res, expect, ctx) => {\n  let prop = res[0];\n  let index = res[0].length;\n  let op = 'prop';\n  if (type === 'dot') {\n    if (res[1]) {\n      op = '?prop';\n    }\n    let matches = part.substring(res[0].length).toString().match(expectTypes.prop.types.prop);\n    if (matches && matches.length) {\n      prop = matches[0];\n      index = prop.length + res[0].length\n    } else {\n      throw new SyntaxError('Hanging  dot');\n    }\n  }\n  ctx.lispTree = lispify(constants, part.substring(index), expectTypes[expect].next, createLisp<Prop|PropOptional>({\n    op: typesCreate[op], \n    a: ctx.lispTree, \n    b: prop\n  }));\n});\n\nsetLispType(['spreadArray', 'spreadObject'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = createLisp<SpreadArray|SpreadObject>({\n    op: type === 'spreadArray' ? LispType.SpreadArray : LispType.SpreadObject,\n    a: LispType.None,\n    b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)\n  });\n});\n\nsetLispType(['return', 'throw'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = createLisp<Return|Throw>({\n    op: type === 'return' ? LispType.Return : LispType.Throw,\n    a: LispType.None,\n    b: lispifyExpr(constants, part.substring(res[0].length))\n  });\n});\n\nsetLispType(['number', 'boolean', 'null', 'und', 'NaN', 'Infinity'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp<Number|BigInt|GlobalSymbol>({\n    op: type === \"number\" ? res[10] ? LispType.BigInt : LispType.Number : LispType.GlobalSymbol,\n    a: LispType.None,\n    b: res[10] ? res[1] : res[0]\n  }));\n});\n\nsetLispType(['string', 'literal', 'regex'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp<StringIndex|LiteralIndex|RegexIndex>({\n    op: type === 'string' ? LispType.StringIndex : type === 'literal' ? LispType.LiteralIndex : LispType.RegexIndex,\n    a: LispType.None,\n    b: res[1],\n  }));\n});\n\nsetLispType(['initialize'] as const, (constants, type, part, res, expect, ctx) => {\n  const lt = res[1] === 'var' ? LispType.Var : res[1] === 'let' ? LispType.Let : LispType.Const;\n  if (!res[3]) {\n    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp<Var|Let|Const>({\n      op: lt,\n      a: res[2],\n      b: LispType.None\n    }));\n  } else {\n    ctx.lispTree = createLisp<Var|Let|Const>({\n      op: lt,\n      a: res[2],\n      b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)\n    });\n  }\n});\n\nsetLispType(['function', 'inlineFunction', 'arrowFunction', 'arrowFunctionSingle'] as const, (constants, type, part, res, expect, ctx) => {\n  const isArrow = type !== 'function' && type !== 'inlineFunction';\n  const isReturn = isArrow && !res[res.length - 1];\n  const argPos = isArrow ? 2 : 3;\n  const isAsync = res[1] ? LispType.True : LispType.None;\n  const args: (string|typeof isAsync)[] = res[argPos] ? res[argPos].replace(/\\s+/g, \"\").split(/,/g) : [];\n  if (!isArrow) {\n    args.unshift((res[2] || \"\").trimStart());\n  }\n  let ended = false;\n  args.forEach((arg: string) => {\n    if (ended) throw new SyntaxError('Rest parameter must be last formal parameter');\n    if (arg.startsWith('...')) ended = true;\n  });\n  args.unshift(isAsync);\n  const f = restOfExp(constants, part.substring(res[0].length), !isReturn ? [/^}/] : [/^[,\\)\\}\\]]/, semiColon])\n  const func = (isReturn ? 'return ' + f : f.toString());\n  ctx.lispTree = lispify(constants, part.substring(res[0].length + func.length + 1), expectTypes[expect].next, createLisp<Function|InlineFunction|ArrowFunction>({\n    op: isArrow ? LispType.ArrowFunction : type === 'function' ? LispType.Function : LispType.InlineFunction,\n    a: args,\n    b: constants.eager ? lispifyFunction(new CodeString(func), constants) : func\n  }));\n});\n\nconst iteratorRegex = /^((let|var|const)\\s+)?\\s*([a-zA-Z\\$_][a-zA-Z\\d\\$_]*)\\s+(in|of)(?![\\w\\$])/\nsetLispType(['for', 'do', 'while'] as const, (constants, type, part, res, expect, ctx) => {\n  let i = 0;\n  let startStep: LispItem = LispType.True;\n  let startInternal: Lisp[] = [];\n  let getIterator: Lisp;\n  let beforeStep: LispItem = LispType.None;\n  let checkFirst = LispType.True;\n  let condition: LispItem;\n  let step: LispItem = LispType.True;\n  let body: CodeString;\n  switch (type) {\n    case 'while':\n      i = part.toString().indexOf(\"(\") + 1;\n      let extract = restOfExp(constants, part.substring(i), [], \"(\");\n      condition = lispifyReturnExpr(constants, extract);\n      body = restOfExp(constants, part.substring(i + extract.length + 1)).trim();\n      if (body[0] === \"{\") body = body.slice(1, -1);\n      break;\n    case 'for':\n      i = part.toString().indexOf(\"(\") + 1;\n      let args: CodeString[] = [];\n      let extract2 = emptyString;\n      for (let k = 0; k < 3; k++)  {\n        extract2 = restOfExp(constants, part.substring(i), [/^[;\\)]/]);\n        args.push(extract2.trim());\n        i += extract2.length + 1;\n        if (part.char(i - 1) === \")\") break;\n      }\n      let iterator: RegExpExecArray;\n      if (args.length === 1 && (iterator = iteratorRegex.exec(args[0].toString()))) {\n        if (iterator[4] === 'of') {\n          getIterator = lispifyReturnExpr(constants, args[0].substring(iterator[0].length)),\n          startInternal = [\n            ofStart2, \n            ofStart3\n          ];\n          condition = ofCondition;\n          step = ofStep;\n          beforeStep = lispify(constants, new CodeString((iterator[1] || 'let ') + iterator[3]  + ' = $$next.value'), ['initialize']);\n        } else {\n          getIterator = lispifyReturnExpr(constants, args[0].substring(iterator[0].length)),\n          startInternal = [\n            inStart2,\n            inStart3\n          ];\n          step = inStep;\n          condition = inCondition;\n          beforeStep = lispify(constants, new CodeString((iterator[1] || 'let ') + iterator[3] + ' = $$keys[$$keyIndex]'), ['initialize']);\n        }\n      } else if (args.length === 3) {\n        startStep = lispifyExpr(constants, args.shift(), startingExecpted);\n        condition = lispifyReturnExpr(constants, args.shift());\n        step = lispifyExpr(constants, args.shift());\n      } else {\n        throw new SyntaxError(\"Invalid for loop definition\");\n      }\n      body = restOfExp(constants, part.substring(i)).trim();\n      if (body[0] === \"{\") body = body.slice(1, -1);\n\n      break;\n    case 'do':\n      checkFirst = LispType.None;\n      const isBlock = !!res[3];\n      body = restOfExp(constants, part.substring(res[0].length), isBlock ? [/^\\}/] : [semiColon]);\n      condition = lispifyReturnExpr(constants, restOfExp(constants, part.substring(part.toString().indexOf(\"(\", res[0].length + body.length) + 1), [], \"(\"));\n      break;\n  }\n  const a = [checkFirst, startInternal, getIterator, startStep, step, condition, beforeStep] as LispItem;\n  ctx.lispTree = createLisp<Loop>({\n    op: LispType.Loop,\n    a,\n    b: lispifyBlock(body, constants)\n  });\n});\n\nsetLispType(['block'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = createLisp<Block>({\n    op: LispType.Block,\n    a: lispifyBlock(restOfExp(constants, part.substring(1), [], \"{\"), constants),\n    b: LispType.None\n  });\n});\n\nsetLispType(['loopAction'] as const, (constants, type, part, res, expect, ctx) => {\n  ctx.lispTree = createLisp<LoopAction>({\n    op: LispType.LoopAction,\n    a: res[1],\n    b: LispType.None\n  });\n});\n\nconst catchReg = /^\\s*(catch\\s*(\\(\\s*([a-zA-Z\\$_][a-zA-Z\\d\\$_]*)\\s*\\))?|finally)\\s*\\{/\nsetLispType(['try'] as const, (constants, type, part, res, expect, ctx) => {\n  const body = restOfExp(constants, part.substring(res[0].length), [], \"{\");\n  let catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());\n  let finallyBody;\n  let exception = \"\";\n  let catchBody;\n  let offset = 0;\n  if (catchRes[1].startsWith('catch')) {\n    catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());\n    exception = catchRes[2];\n    catchBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], \"{\");\n    offset = res[0].length + body.length + 1 + catchRes[0].length + catchBody.length + 1;\n    if ((catchRes = catchReg.exec(part.substring(offset).toString())) && catchRes[1].startsWith('finally')) {\n      finallyBody = restOfExp(constants, part.substring(offset + catchRes[0].length), [], \"{\");\n    }\n  } else {\n    finallyBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], \"{\");\n  }\n  const b = [\n    exception,\n    lispifyBlock(insertSemicolons(constants, catchBody || emptyString), constants),\n    lispifyBlock(insertSemicolons(constants, finallyBody || emptyString), constants),\n  ] as LispItem;\n  ctx.lispTree = createLisp<Try>({\n    op: LispType.Try,\n    a: lispifyBlock(insertSemicolons(constants, body), constants),\n    b\n  });\n});\n\nsetLispType(['void', 'await'] as const, (constants, type, part, res, expect, ctx) => {\n  const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\\s\\.\\?\\w\\$]|\\?[^\\.])/]);\n  ctx.lispTree = lispify(constants, part.substring(res[0].length + extract.length), expectTypes[expect].next, createLisp<Void|Await>({\n    op: type === 'void' ? LispType.Void : LispType.Await,\n    a: lispify(constants, extract),\n    b: LispType.None\n  }));\n});\n\nsetLispType(['new'] as const, (constants, type, part, res, expect, ctx) => {\n  let i = res[0].length;\n  const obj = restOfExp(constants, part.substring(i), [], undefined, \"(\");\n  i += obj.length + 1;\n  const args: CodeString[] = [];\n  if (part.char(i - 1) === \"(\") {\n    const argsString = restOfExp(constants, part.substring(i), [], \"(\");\n    i += argsString.length + 1;\n    let found: CodeString;\n    let j = 0;\n    while((found = restOfExp(constants, argsString.substring(j), [/^,/])).length) {\n      j += found.length + 1;\n      args.push(found.trim());\n    }\n  }\n  ctx.lispTree = lispify(constants, part.substring(i), expectTypes.expEdge.next, createLisp({\n    op: LispType.New,\n    a: lispify(constants, obj, expectTypes.initialize.next),\n    b: args.map((arg) => lispify(constants, arg, expectTypes.initialize.next)),\n  }));\n});\n\nconst ofStart2 = lispify(undefined, new CodeString('let $$iterator = $$obj[Symbol.iterator]()'), ['initialize']);\nconst ofStart3 = lispify(undefined, new CodeString('let $$next = $$iterator.next()'), ['initialize']);\nconst ofCondition = lispify(undefined, new CodeString('return !$$next.done'), ['initialize']);\nconst ofStep = lispify(undefined, new CodeString('$$next = $$iterator.next()'));\nconst inStart2 = lispify(undefined, new CodeString('let $$keys = Object.keys($$obj)'), ['initialize']);\nconst inStart3 = lispify(undefined, new CodeString('let $$keyIndex = 0'), ['initialize']);\nconst inStep = lispify(undefined, new CodeString('$$keyIndex++'));\nconst inCondition = lispify(undefined, new CodeString('return $$keyIndex < $$keys.length'), ['initialize']);\n\nvar lastType;\nvar lastPart;\nvar lastLastPart;\nvar lastLastLastPart;\nvar lastLastLastLastPart;\nfunction lispify(constants: IConstants, part: CodeString, expected?: readonly string[], lispTree?: Lisp, topLevel = false): Lisp {\n  lispTree = lispTree || [LispType.None,LispType.None,LispType.None];\n  expected = expected || expectTypes.initialize.next;\n  if (part === undefined) return lispTree;\n\n  part = part.trimStart();\n  const str = part.toString();\n  if (!part.length && !expected.includes('expEnd')) {\n    throw new SyntaxError(\"Unexpected end of expression\");\n  }\n  if (!part.length) return lispTree;\n\n  let ctx = {lispTree: lispTree};\n\n  let res: any;\n  for (let expect of expected) {\n    if (expect === 'expEnd') {\n      continue;\n    }\n    for (let type in expectTypes[expect].types) {\n      if (type === 'expEnd') {\n        continue;\n      }\n      if(res = expectTypes[expect].types[type].exec(str)) {\n        lastType = type;\n        lastLastLastLastPart = lastLastLastPart;\n        lastLastLastPart = lastLastPart;\n        lastLastPart = lastPart;\n        lastPart = part;\n        try {\n          lispTypes.get(type)(constants, type, part, res, expect, ctx);\n        } catch(e) {\n          if (topLevel && e instanceof SyntaxError) {\n            throw new ParseError(e.message, str);\n          }\n          throw e;\n        }\n        break;\n      }\n    }\n    if (res) break;\n  }\n\n  if (!res && part.length) {\n    let msg = `Unexpected token after ${lastType}: ${part.char(0)}`;\n    if (topLevel) {\n      throw new ParseError(`Unexpected token after ${lastType}: ${part.char(0)}`, str);\n    }\n    throw new SyntaxError(`Unexpected token after ${lastType}: ${part.char(0)}`);\n  }\n  return ctx.lispTree;\n}\n\nconst startingExpectedWithoutSingle = startingExecpted.filter((r) => r !== 'expSingle');\n\nfunction lispifyExpr(constants: IConstants, str: CodeString, expected?: readonly string[]): Lisp {\n  if (!str.trimStart().length) return undefined;\n  let subExpressions: CodeString[] = [];\n  let sub: CodeString;\n  let pos = 0;\n  expected = expected || expectTypes.initialize.next;\n  if (expected.includes('expSingle')) {\n    if (testMultiple(str.toString(), Object.values(expectTypes.expSingle.types))) {\n      return lispify(constants, str, ['expSingle'], undefined, true);\n    }\n  }\n  if (expected === startingExecpted) expected = startingExpectedWithoutSingle;\n  while ((sub = restOfExp(constants, str.substring(pos), [/^,/])).length) {\n    subExpressions.push(sub.trimStart());\n    pos += sub.length + 1;\n  }\n  if (subExpressions.length === 1) {\n    return lispify(constants, str, expected, undefined, true);\n  }\n  if (expected.includes('initialize')) {\n    let defined = expectTypes.initialize.types.initialize.exec(subExpressions[0].toString());\n    if (defined) {\n      return createLisp<Block>({\n        op: LispType.Block,\n        a: subExpressions.map((str, i) => lispify(constants, i ? new CodeString(defined[1] + ' ' + str) : str, ['initialize'], undefined, true)),\n        b: LispType.None\n      });\n    } else if (expectTypes.initialize.types.return.exec(subExpressions[0].toString())) {\n      return lispify(constants, str, expected, undefined, true);\n    }\n  }\n  const exprs = subExpressions.map((str, i) => lispify(constants, str, expected, undefined, true));\n  return createLisp<Expression>({op: LispType.Expression, a: exprs, b: LispType.None});\n}\n\nexport function lispifyReturnExpr(constants: IConstants, str: CodeString) {\n  return createLisp<Return>({op: LispType.Return, a: LispType.None, b: lispifyExpr(constants, str)})\n}\n\nexport function lispifyBlock(str: CodeString, constants: IConstants, expression = false): Lisp[] {\n  str = insertSemicolons(constants, str);\n  if (!str.trim().length) return [];\n  let parts: CodeString[] = [];\n  let part: CodeString;\n  let pos = 0;\n  let start = 0;\n  let details: restDetails = {};\n  let skipped = false;\n  let isInserted = false;\n  while ((part = restOfExp(constants, str.substring(pos), [semiColon], undefined, undefined, undefined, details)).length) {\n    isInserted = str.char(pos + part.length) && str.char(pos + part.length) !== ';';\n    pos += part.length + (isInserted ? 0 : 1);\n    if (/^\\s*else(?![\\w\\$])/.test(str.substring(pos).toString())) {\n      skipped = true;\n    } else if (details.words.includes('do') && /^\\s*while(?![\\w\\$])/.test(str.substring(pos).toString())) {\n      skipped = true;\n    } else {\n      skipped = false;\n      parts.push(str.substring(start, pos - (isInserted ? 0 : 1)));\n      start = pos;\n    }\n    details = {};\n    if (expression) break;\n  }\n  if (skipped) {\n    parts.push(str.substring(start, pos - (isInserted ? 0 : 1)));\n  }\n  return parts.map((str) => str.trimStart()).filter((str) => str.length).map((str, j) => {\n    return lispifyExpr(constants, str.trimStart(), startingExecpted);\n  });\n}\n\nexport function lispifyFunction(str: CodeString, constants: IConstants, expression = false): Lisp[] {\n  if (!str.trim().length) return [];\n  const tree = lispifyBlock(str, constants, expression);\n  let hoisted: Lisp[] = [];\n  hoist(tree, hoisted);\n  return hoisted.concat(tree);\n}\n\nexport function isLisp<Type extends Lisp = Lisp>(item: LispItem|LispItem): item is Type {\n  return Array.isArray(item) && typeof item[0] === 'number' && item[0] !== LispType.None && item[0] !== LispType.True;\n}\n\nfunction hoist(item: LispItem|LispItem, res: Lisp[]): boolean {\n  if (isLisp(item)) {\n    const [op, a, b] = item;\n    if (op === LispType.Try || op === LispType.If || op === LispType.Loop || op === LispType.Switch) {\n      hoist(a, res);\n      hoist(b, res);\n    } else if (op === LispType.Var) {\n      res.push(createLisp({op: LispType.Var, a: a, b: LispType.None}));\n    } else if (op === LispType.Function && a[1]) {\n      res.push(item);\n      return true;\n    }\n  } else if (Array.isArray(item)) {\n    const rep = [];\n    for (let it of item) {\n      if (!hoist(it, res)) {\n        rep.push(it);\n      }\n    }\n    if (rep.length !== item.length) {\n      item.length = 0;\n      item.push(...rep);\n    }\n  }\n  return false;\n}\n\nconst closingsNoInsertion = /^(\\})\\s*(catch|finally|else|while|instanceof)(?![\\w\\$])/\n                    //  \\w|)|] \\n \\w = 2                                  // \\} \\w|\\{ = 5 \nconst colonsRegex = /^((([\\w\\$\\]\\)\\\"\\'\\`]|\\+\\+|\\-\\-)\\s*\\r?\\n\\s*([\\w\\$\\+\\-\\!~]))|(\\}\\s*[\\w\\$\\!~\\+\\-\\{\\(\\\"\\'\\`]))/\n\n// if () \\w \\n; \\w              == \\w \\n \\w    | last === if             a\n// if () { }; \\w                == \\} ^else    | last === if             b\n// if () \\w \\n; else \\n \\w \\n;  == \\w \\n \\w    | last === else           a\n// if () {} else {}; \\w         == \\} \\w       | last === else           b\n// while () \\n \\w \\n; \\w        == \\w \\n \\w    | last === while          a\n// while () { }; \\w             == \\} \\w       | last === while          b\n// do \\w \\n; while (); \\w       == \\w \\n while | last === do             a\n// do { } while (); \\w          == \\) \\w       | last === while          c\n// try {} catch () {}; \\w       == \\} \\w       | last === catch|finally  b\n// \\w \\n; \\w                    == \\w \\n \\w    | last === none           a\n// cb() \\n \\w                   == \\) \\n \\w    | last === none           a\n// obj[a] \\n \\w                 == \\] \\n \\w    | last === none           a\n// {} {}                        == \\} \\{       | last === none           b\n\nexport function insertSemicolons(constants: IConstants, str: CodeString): CodeString {\n  let rest = str;\n  let sub = emptyString;\n  let details: restDetails = {};\n  const inserted = insertedSemicolons.get(str.ref) || new Array(str.ref.str.length);\n  while ((sub = restOfExp(constants, rest, [], undefined, undefined, [colonsRegex], details)).length) {\n    let valid = false;\n    let part = sub;\n    let edge = sub.length;\n    if (details.regRes) {\n      valid = true;\n      const [,, a,,, b] = details.regRes;\n      edge = details.regRes[3] === \"++\" || details.regRes[3] === \"--\" ? sub.length + 1 : sub.length;\n      part = rest.substring(0,  edge);\n      if (b) {\n        let res = closingsNoInsertion.exec(rest.substring(sub.length - 1).toString());\n        if (res) {\n          if (res[2] === 'while') {\n            valid = details.lastWord !== 'do';\n          } else {\n            valid = false;\n          }\n        } else if (details.lastWord === 'function' && details.regRes[5][0] === \"}\" && details.regRes[5].slice(-1) === '(') {\n          valid = false;\n        } \n\n      } else if (a) {\n        if (details.lastWord === 'if' || details.lastWord === 'while' || details.lastWord === 'for' || details.lastWord === 'else') {\n          valid = false;\n        }\n      }\n    }\n    if (valid) {\n      inserted[part.end] = true;\n    }\n    rest = rest.substring(edge);\n    details = {};\n  }\n  insertedSemicolons.set(str.ref, inserted);\n  return str;\n}\n\nexport function checkRegex(str: string): IRegEx | null {\n  let i = 1;\n  let escape = false;\n  let done = false;\n  let cancel = false;\n  while (i < str.length && !done && !cancel) {\n    done = (str[i] === '/' && !escape);\n    escape = str[i] === '\\\\' && !escape;\n    cancel = str[i] === '\\n';\n    i++;\n  }\n  let after = str.substring(i);\n  cancel = (cancel || !done) || /^\\s*\\d/.test(after);\n  if (cancel) return null;\n  let flags = /^[a-z]*/.exec(after);\n  if(/^\\s+[\\w\\$]/.test(str.substring(i + flags[0].length))) {\n    return null;\n  }\n  return {\n    regex: str.substring(1, i-1),\n    flags: (flags && flags[0]) || \"\",\n    length: i + ((flags && flags[0].length) || 0)\n  }\n}\n\nconst notDivide = /(typeof|delete|instanceof|return|in|of|throw|new|void|do|if)$/\nconst possibleDivide = /^([\\w\\$\\]\\)]|\\+\\+|\\-\\-)[\\s\\/]/;\nexport function extractConstants(constants: IConstants, str: string, currentEnclosure = \"\"): {str: string, length: number} {\n  let quote;\n  let extract: (string|number)[] = [];\n  let escape = false;\n  let regexFound: IRegEx;\n  let comment = \"\";\n  let commentStart = -1;\n  let currJs: string[] = [];\n  let char: string = \"\";\n  const strRes: (string|number)[] = [];\n  const enclosures: string[] = [];\n  let isPossibleDivide: RegExpExecArray;\n  for (var i = 0; i < str.length; i++) {\n    char = str[i];\n    if (comment) {\n      if (char === comment) {\n        if (comment === \"*\" && str[i + 1] ===\"/\") {\n          comment = \"\";\n          i++\n        } else if (comment === \"\\n\") {\n          comment = \"\";\n        }\n      }\n    } else {\n      if (escape) {\n        escape = false;\n        extract.push(char);\n        continue;\n      }\n\n      if (quote) {\n        if (quote === \"`\" && char === \"$\" && str[i+1] === \"{\") {\n          let skip = extractConstants(constants, str.substring(i+2), \"{\");\n          currJs.push(skip.str);\n          extract.push('${', currJs.length - 1, `}`);\n          i += skip.length + 2;\n        } else if (quote === char) {\n          if (quote === '`') {\n            const li = createLisp<Literal>({\n              op: LispType.Literal,\n              a:  unraw(extract.join(\"\")),\n              b: [],\n            });\n            li.tempJsStrings = currJs\n            constants.literals.push(li);\n            strRes.push(`\\``, constants.literals.length - 1, `\\``);\n          } else {\n            constants.strings.push(unraw(extract.join(\"\")));\n            strRes.push(`\"`, constants.strings.length - 1, `\"`);\n          }\n          quote = null;\n          extract = [];\n        } else {\n          extract.push(char);\n        }\n      } else {\n        if ((char === \"'\"  || char === '\"'  || char === '`')) {\n          currJs = [];\n          quote = char;\n        } else if (closings[currentEnclosure] === char && !enclosures.length) {\n          return {str: strRes.join(\"\"), length: i}\n        } else if (closings[char]) {\n          enclosures.push(char);\n          strRes.push(char);\n        } else if (closings[enclosures[enclosures.length-1]] === char) {\n          enclosures.pop();\n          strRes.push(char);\n        } else if (char === \"/\" && (str[i+1] === \"*\" || str[i+1] === \"/\")) {\n          comment = str[i+1] === \"*\" ? \"*\" : \"\\n\";\n          commentStart = i;\n        } else if (char === '/' && !isPossibleDivide && (regexFound = checkRegex(str.substring(i)))) {\n          constants.regexes.push(regexFound);\n          strRes.push(`/`, constants.regexes.length - 1, `/r`);\n          i += regexFound.length - 1;\n        } else {\n          strRes.push(char);\n        }\n\n        if (!isPossibleDivide || !space.test(char)) {\n          if (isPossibleDivide = possibleDivide.exec(str.substring(i))) {\n            if (notDivide.test(str.substring(0, i + isPossibleDivide[1].length))) {\n              isPossibleDivide = null;\n            }\n          }\n        }\n      }\n      escape = quote && char === \"\\\\\";\n    }\n  }\n\n  if (comment) {\n    if (comment === \"*\") {\n      throw new SyntaxError(`Unclosed comment '/*': ${str.substring(commentStart)}`)\n    }\n  }\n  return {str: strRes.join(\"\"), length: i}\n}\nexport function parse(code: string, eager = false, expression = false): IExecutionTree {\n  if (typeof code !== 'string') throw new ParseError(`Cannot parse ${code}`, code);\n  let str = ' ' + code;\n  const constants: IConstants = {strings: [], literals: [], regexes: [], eager};\n  str = extractConstants(constants, str).str;\n\n  for (let l of constants.literals) {\n    l[2] = l.tempJsStrings.map((js: string) => lispifyExpr(constants, new CodeString(js)));\n    delete l.tempJsStrings;\n  }\n  return {tree: lispifyFunction(new CodeString(str), constants, expression), constants};\n}\n","import { LispItem, Lisp, parse, IRegEx, lispifyFunction, CodeString, LispType, LispFamily, ExtractLispOp, isLisp, SwitchCase } from \"./parser.js\";\nimport { IExecContext, Ticks } from \"./Sandbox.js\";\n\nexport type SandboxFunction = (code: string, ...args: unknown[]) => () => unknown;\nexport type sandboxedEval = (code: string) => unknown;\nexport type sandboxSetTimeout = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => any;\nexport type sandboxSetInterval = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => any;\nexport type Done = (err?: unknown, res?: unknown) => void\nexport class ExecReturn<T> {\n  constructor(public auditReport: IAuditReport, public result: T, public returned: boolean, public breakLoop = false, public continueLoop = false) {}\n}\n\nexport interface IAuditReport {\n  globalsAccess: Set<unknown>;\n  prototypeAccess: {[name: string]: Set<string>}\n}\n\nexport interface IGlobals {\n  [key: string]: unknown\n}\n\nexport interface IChange {\n  type: string;\n}\n\nexport interface ICreate extends IChange {\n  type: \"create\";\n  prop: number|string;\n}\n\nexport interface IReplace extends IChange {\n  type: \"replace\";\n}\n\nexport interface IDelete extends IChange {\n  type: \"delete\";\n  prop: number|string;\n}\n\nexport interface IReverse extends IChange {\n  type: \"reverse\";\n}\n\nexport interface ISort extends IChange {\n  type: \"sort\";\n}\n\nexport interface IPush extends IChange {\n  type: \"push\";\n  added: unknown[];\n}\n\nexport interface IPop extends IChange {\n  type: \"pop\";\n  removed: unknown[];\n}\n\nexport interface IShift extends IChange {\n  type: \"shift\";\n  removed: unknown[];\n}\n\nexport interface IUnShift extends IChange {\n  type: \"unshift\";\n  added: unknown[];\n}\n\nexport interface ISplice extends IChange {\n  type: \"splice\";\n  startIndex: number;\n  deleteCount: number; \n  added: unknown[];\n  removed: unknown[];\n\n}\n\nexport interface ICopyWithin extends IChange {\n  type: \"copyWithin\";\n  startIndex: number;\n  endIndex: number;\n  added: unknown[];\n  removed: unknown[];\n}\n\nexport type Change = ICreate | IReplace | IDelete | IReverse | ISort | IPush | IPop | IUnShift | IShift | ISplice | ICopyWithin\n\nexport class Prop {\n  constructor(public context: {[key:string]: any}, public prop: string, public isConst = false, public isGlobal = false, public isVariable = false) {\n  }\n\n  get<T = unknown>(context: IExecContext): T {\n    if (this.context === undefined) throw new ReferenceError(`${this.prop} is not defined`);\n    context.getSubscriptions.forEach((cb) => cb(this.context, this.prop))\n    return this.context[this.prop];\n  }\n}\n\nconst optional = {};\n\nconst reservedWords = new Set([\n  'instanceof',\n  'typeof',\n  'return',\n  'try',\n  'catch',\n  'if',\n  'finally',\n  'else',\n  'in',\n  'of',\n  'var',\n  'let',\n  'const',\n  'for',\n  'delete',\n  'false',\n  'true',\n  'while',\n  'do',\n  'break',\n  'continue',\n  'new',\n  'function',\n  'async',\n  'await',\n  'switch',\n  'case'\n]);\n\nenum VarType {\n  let = \"let\",\n  const = \"const\",\n  var = \"var\"\n}\n\nfunction keysOnly(obj: unknown): {[key: string]: true} {\n  const ret = Object.assign({}, obj);\n  for (let key in ret) {\n    ret[key] = true;\n  }\n  return ret;\n}\n\nexport class Scope {\n  parent: Scope;\n  const: {[key: string]: true} = {};\n  let: {[key: string]: true} = {};\n  var: {[key: string]: true} = {};\n  globals: {[key: string]: true};\n  allVars: {[key:string]: unknown} & Object;\n  functionThis?: unknown;\n  constructor(parent: Scope, vars = {}, functionThis?: unknown) {\n    const isFuncScope = functionThis !== undefined || parent === null;\n    this.parent = parent;\n    this.allVars = vars;\n    this.let = isFuncScope ? this.let : keysOnly(vars);\n    this.var = isFuncScope ? keysOnly(vars) : this.var;\n    this.globals = parent === null ? keysOnly(vars) : {};\n    this.functionThis = functionThis;\n  }\n\n  get(key: string, functionScope = false): Prop {\n    if (key === 'this' && this.functionThis !== undefined) {\n      return new Prop({this: this.functionThis}, key, true, false, true);\n    }\n    if (reservedWords.has(key)) throw new SyntaxError(\"Unexepected token '\" + key + \"'\");\n    if (this.parent === null || !functionScope || this.functionThis !== undefined) {\n      if (this.globals.hasOwnProperty(key)) {\n        return new Prop(this.functionThis, key, false, true, true);\n      }\n      if (key in this.allVars && (!(key in {}) || this.allVars.hasOwnProperty(key))) {\n        return new Prop(this.allVars, key, this.const.hasOwnProperty(key), this.globals.hasOwnProperty(key), true);\n      }\n      if (this.parent === null) {\n        return new Prop(undefined, key);\n      }\n    }\n    return this.parent.get(key, functionScope)\n  }\n\n  set(key: string, val: unknown) {\n    if (key === 'this') throw new SyntaxError('\"this\" cannot be assigned')\n    if (reservedWords.has(key)) throw new SyntaxError(\"Unexepected token '\" + key + \"'\");\n    let prop = this.get(key);\n    if(prop.context === undefined) {\n      throw new ReferenceError(`Variable '${key}' was not declared.`);\n    }\n    if (prop.isConst) {\n      throw new TypeError(`Cannot assign to const variable '${key}'`);\n    }\n    if (prop.isGlobal) {\n      throw new SandboxError(`Cannot override global variable '${key}'`);\n    }\n    prop.context[prop.prop] = val;\n    return prop;\n  }\n\n  declare(key: string, type: VarType = null, value: unknown = undefined, isGlobal = false): Prop {\n    if (key === 'this') throw new SyntaxError('\"this\" cannot be declared');\n    if (reservedWords.has(key)) throw new SyntaxError(\"Unexepected token '\" + key + \"'\");\n    if (type === 'var' && this.functionThis === undefined && this.parent !== null) {\n      return this.parent.declare(key, type, value, isGlobal)\n    } else if ((this[type].hasOwnProperty(key) && type !== 'const' && !this.globals.hasOwnProperty(key)) || !(key in this.allVars)) {\n      if (isGlobal) {\n        this.globals[key] = true;\n      }\n      this[type][key] = true;\n      this.allVars[key] = value;\n    } else {\n      throw new SandboxError(`Identifier '${key}' has already been declared`);\n    }\n    return new Prop(this.allVars, key, this.const.hasOwnProperty(key), isGlobal);\n  }\n}\n\nexport interface IScope {\n  [key: string]: any;\n}\n\nexport class FunctionScope implements IScope {}\n\nexport class LocalScope implements IScope {}\n\nexport class SandboxError extends Error {}\n\nlet currentTicks: Ticks;\n\nexport function sandboxFunction(context: IExecContext, ticks?: Ticks): SandboxFunction {\n  return SandboxFunction;\n  function SandboxFunction(...params: string[]) {\n    let code = params.pop() || \"\";\n    let parsed = parse(code);\n    return createFunction(params, parsed.tree, ticks || currentTicks, {\n      ...context,\n      constants: parsed.constants,\n      tree: parsed.tree\n    }, undefined, 'anonymous');\n  }\n}\n\nfunction generateArgs(argNames: string[], args: unknown[]) {\n  const vars: unknown = {};\n  argNames.forEach((arg, i) => {\n    if (arg.startsWith('...')) {\n      vars[arg.substring(3)] = args.slice(i);\n    } else {\n      vars[arg] = args[i];\n    }\n  });\n  return vars;\n}\n\nconst sandboxedFunctions = new WeakSet();\nexport function createFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string) {\n  if (context.ctx.options.forbidFunctionCreation) {\n    throw new SandboxError(\"Function creation is forbidden\");\n  }\n  let func;\n  if (name === undefined) {\n    func = (...args) => {\n      const vars = generateArgs(argNames, args);\n      const res = executeTree(ticks, context, parsed, scope === undefined ? [] : [new Scope(scope, vars)])\n      return res.result;\n    }\n  } else {\n    func = function sandboxedObject(...args) {\n      const vars = generateArgs(argNames, args);\n      const res = executeTree(ticks, context, parsed, scope === undefined ? [] : [new Scope(scope, vars, this)])\n      return res.result;\n    }\n  }\n  context.registerSandboxFunction(func);\n  sandboxedFunctions.add(func);\n  return func;\n}\n\nexport function createFunctionAsync(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string) {\n  if (context.ctx.options.forbidFunctionCreation) {\n    throw new SandboxError(\"Function creation is forbidden\");\n  }\n  if (!context.ctx.prototypeWhitelist?.has(Promise.prototype)) {\n    throw new SandboxError(\"Async/await not permitted\");\n  }\n  let func;\n  if (name === undefined) {\n    func = async (...args) => {\n      const vars = generateArgs(argNames, args);\n      const res = await executeTreeAsync(ticks, context, parsed, scope === undefined ? [] : [new Scope(scope, vars)])\n      return res.result;\n    }\n  } else {\n    func = async function sandboxedObject(...args) {\n      const vars = generateArgs(argNames, args);\n      const res = await executeTreeAsync(ticks, context, parsed, scope === undefined ? [] : [new Scope(scope, vars, this)])\n      return res.result;\n    }\n  }\n  context.registerSandboxFunction(func);\n  sandboxedFunctions.add(func);\n  return func;\n}\n\nexport function sandboxedEval(func: SandboxFunction): sandboxedEval {\n  return sandboxEval;\n  function sandboxEval(code: string) {\n    return func(code)();\n  }\n}\n\nexport function sandboxedSetTimeout(func: SandboxFunction): sandboxSetTimeout {\n  return function sandboxSetTimeout(handler, ...args) {\n    if (typeof handler !== 'string') return setTimeout(handler, ...args);\n    return setTimeout(func(handler), ...args);\n  }\n}\n\nexport function sandboxedSetInterval(func: SandboxFunction): sandboxSetInterval {\n  return function sandboxSetInterval(handler, ...args) {\n    if (typeof handler !== 'string') return setInterval(handler, ...args);\n    return setInterval(func(handler), ...args);\n  }\n}\n\nexport function assignCheck(obj: Prop, context: IExecContext, op = 'assign') {\n  if(obj.context === undefined) {\n    throw new ReferenceError(`Cannot ${op} value to undefined.`)\n  }\n  if(typeof obj.context !== 'object' && typeof obj.context !== 'function') {\n    throw new SyntaxError(`Cannot ${op} value to a primitive.`)\n  }\n  if (obj.isConst) {\n    throw new TypeError(`Cannot set value to const variable '${obj.prop}'`);\n  }\n  if (obj.isGlobal) {\n    throw new SandboxError(`Cannot ${op} property '${obj.prop}' of a global object`);\n  }\n  if (typeof obj.context[obj.prop] === 'function' && !obj.context.hasOwnProperty(obj.prop)) {\n    throw new SandboxError(`Override prototype property '${obj.prop}' not allowed`);\n  }\n  if (op === \"delete\") {\n    if (obj.context.hasOwnProperty(obj.prop)) {\n      context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb({type: \"delete\", prop: obj.prop}));\n      context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb({type: \"delete\", prop: obj.prop}));\n    }\n  } else if (obj.context.hasOwnProperty(obj.prop)) {\n    context.setSubscriptions.get(obj.context)?.get(obj.prop)?.forEach((cb) => cb({\n      type: \"replace\"\n    }));\n    context.setSubscriptionsGlobal.get(obj.context)?.get(obj.prop)?.forEach((cb) => cb({\n      type: \"replace\"\n    }));\n  } else {\n    context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb({type: \"create\", prop: obj.prop}));\n    context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb({type: \"create\", prop: obj.prop}));\n  }\n}\nconst arrayChange = new Set([\n  [].push,\n  [].pop,\n  [].shift,\n  [].unshift,\n  [].splice,\n  [].reverse,\n  [].sort,\n  [].copyWithin\n]);\n\nexport class KeyVal {\n  constructor(public key: string|SpreadObject, public val: unknown) {}\n}\n\nexport class SpreadObject {\n  constructor(public item: {[key: string]: unknown}) {}\n}\n\nexport class SpreadArray {\n  constructor(public item: unknown[]) {}\n}\n\nexport class If {\n  constructor(public t: Lisp, public f: Lisp) {}\n}\n\nconst literalRegex = /(\\$\\$)*(\\$)?\\${(\\d+)}/g;\ntype OpCallback = (exec: Execution, done: Done, ticks: Ticks, a: any, b: any, obj: any, context: IExecContext, scope: Scope, bobj?: any, inLoopOrSwitch?: string) => void;\n\nexport const ops = new Map<LispType, OpCallback>();\nexport function addOps<Type extends LispFamily>(type: ExtractLispOp<Type>, cb: OpCallback) {\n  ops.set(type, cb);\n}\n\naddOps(LispType.Prop, (exec, done, ticks, a, b: string, obj, context, scope) => {\n    if(a === null) {\n      throw new TypeError(`Cannot get property ${b} of null`);\n    }\n    const type = typeof a;\n    if (type === 'undefined' && obj === undefined) {\n      let prop = scope.get(b);\n      if (prop.context === context.ctx.sandboxGlobal) {\n        if (context.ctx.options.audit) {\n          context.ctx.auditReport.globalsAccess.add(b);\n        }\n        const rep = context.ctx.globalsWhitelist.has(context.ctx.sandboxGlobal[b]) ? context.evals.get(context.ctx.sandboxGlobal[b]) : undefined;\n        if (rep) {\n          done(undefined, rep);\n          return;\n        }\n      }\n      if (prop.context && prop.context[b] === globalThis) {\n        done(undefined, context.ctx.globalScope.get('this'));\n        return;\n      }\n\n      done(undefined, prop);\n      return;\n    } else if (a === undefined) {\n      throw new SandboxError(\"Cannot get property '\" + b + \"' of undefined\")\n    }\n\n    if (type !== 'object') {\n      if(type === 'number') {\n        a = new Number(a);\n      } else if(type === 'string') {\n        a = new String(a);\n      } else if(type === 'boolean') {\n        a = new Boolean(a);\n      }\n    } else if (typeof a.hasOwnProperty === 'undefined') {\n      done(undefined, new Prop(undefined, b));\n      return;\n    }\n\n    const isFunction = type === 'function';\n    let prototypeAccess = isFunction || !(a.hasOwnProperty(b) || typeof b === 'number');\n\n    if (context.ctx.options.audit && prototypeAccess) {\n      if (typeof b === 'string') {\n        let prot = Object.getPrototypeOf(a);\n        do {\n          if (prot.hasOwnProperty(b)) {\n            if(!context.ctx.auditReport.prototypeAccess[prot.constructor.name]) {\n              context.ctx.auditReport.prototypeAccess[prot.constructor.name] = new Set();\n            }\n            context.ctx.auditReport.prototypeAccess[prot.constructor.name].add(b);\n          }\n        } while(prot = Object.getPrototypeOf(prot))\n      }\n    }\n\n    if (prototypeAccess) {\n      if (isFunction) {\n        if (!['name', 'length', 'constructor'].includes(b) && a.hasOwnProperty(b)) {\n          const whitelist = context.ctx.prototypeWhitelist.get(a.prototype);\n          const replace = context.ctx.options.prototypeReplacements.get(a);\n          if (replace) {\n            done(undefined, new Prop(replace(a, true), b));\n            return;\n          }\n          if (whitelist && (!whitelist.size || whitelist.has(b))) {\n          } else {\n            throw new SandboxError(`Static method or property access not permitted: ${a.name}.${b}`);\n          }\n        }\n      } else if (b !== 'constructor') {\n        let prot = a;\n        while(prot = Object.getPrototypeOf(prot)) {\n          if (prot.hasOwnProperty(b)) {\n            const whitelist = context.ctx.prototypeWhitelist.get(prot);\n            const replace = context.ctx.options.prototypeReplacements.get(prot.constuctor);\n            if (replace) {\n              done(undefined, new Prop(replace(a, false), b));\n              return;\n            }\n            if (whitelist && (!whitelist.size || whitelist.has(b))) {\n              break;\n            }\n            throw new SandboxError(`Method or property access not permitted: ${prot.constructor.name}.${b}`);\n          }\n        };\n      }\n    }\n\n    if (context.evals.has(a[b])) {\n      done(undefined, context.evals.get(a[b]));\n      return;\n    }\n    if (a[b] === globalThis) {\n      done(undefined, context.ctx.globalScope.get('this'));\n      return;\n    }\n\n    let g = obj.isGlobal || (isFunction && !sandboxedFunctions.has(a)) || context.ctx.globalsWhitelist.has(a);\n\n    done(undefined, new Prop(a, b, false, g));\n  });\n\naddOps(LispType.Call, (exec, done, ticks, a, b: Lisp[], obj, context, scope) => {\n  if (context.ctx.options.forbidFunctionCalls) throw new SandboxError(\"Function invocations are not allowed\");\n  if (typeof a !== 'function') {\n    throw new TypeError(`${typeof obj.prop === 'symbol' ? 'Symbol' : obj.prop} is not a function`);\n  }\n  const vals = b.map((item) => {\n    if (item instanceof SpreadArray) {\n      return [...item.item];\n    } else {\n      return [item];\n    }\n  }).flat().map((item) => valueOrProp(item, context));\n\n  if (typeof obj === 'function') {\n    done(undefined, obj(...vals));\n    return;\n  }\n  if (obj.context[obj.prop] === JSON.stringify && context.getSubscriptions.size) {\n    const cache = new Set<any>();\n    const recurse = (x: unknown) => {\n      if (!x || !(typeof x === 'object') || cache.has(x)) return;\n      cache.add(x);\n      for (let y in x) {\n        context.getSubscriptions.forEach((cb) => cb(x, y));\n        recurse(x[y]);\n      }\n    };\n    recurse(vals[0]);\n  }\n\n  if (obj.context instanceof Array && arrayChange.has(obj.context[obj.prop]) && (context.changeSubscriptions.get(obj.context) || context.changeSubscriptionsGlobal.get(obj.context))) {\n    let change: Change;\n    let changed = false;\n    if (obj.prop === \"push\") {\n      change = {\n        type: \"push\",\n        added: vals\n      }\n      changed = !!vals.length;\n    } else if (obj.prop === \"pop\") {\n      change = {\n        type: \"pop\",\n        removed: obj.context.slice(-1)\n      }\n      changed = !!change.removed.length;\n    }  else if (obj.prop === \"shift\") {\n      change = {\n        type: \"shift\",\n        removed: obj.context.slice(0, 1)\n      }\n      changed = !!change.removed.length;\n    } else if (obj.prop === \"unshift\") {\n      change = {\n        type: \"unshift\",\n        added: vals\n      }\n      changed = !!vals.length;\n    } else if (obj.prop === \"splice\") {\n      change = {\n        type: \"splice\",\n        startIndex: vals[0],\n        deleteCount: vals[1] === undefined ? obj.context.length : vals[1],\n        added: vals.slice(2),\n        removed: obj.context.slice(vals[0], vals[1] === undefined ? undefined : vals[0] + vals[1])\n      }\n      changed = !!change.added.length || !!change.removed.length;\n    } else if (obj.prop === \"reverse\" || obj.prop === \"sort\") {\n      change = {type: obj.prop}\n      changed = !!obj.context.length;\n    } else if (obj.prop === \"copyWithin\") {\n      let len = vals[2] === undefined ? obj.context.length - vals[1] : Math.min(obj.context.length, vals[2] - vals[1]);\n      change = {\n        type: \"copyWithin\",\n        startIndex: vals[0],\n        endIndex: vals[0] + len,\n        added: obj.context.slice(vals[1], vals[1] + len),\n        removed: obj.context.slice(vals[0], vals[0] + len)\n      }\n      changed = !!change.added.length || !!change.removed.length;\n    }\n    if (changed) {\n      context.changeSubscriptions.get(obj.context)?.forEach((cb) => cb(change));\n      context.changeSubscriptionsGlobal.get(obj.context)?.forEach((cb) => cb(change));\n    }\n  }\n  obj.get(context);\n  done(undefined, obj.context[obj.prop](...vals));\n});\n\naddOps(LispType.CreateObject, (exec, done, ticks, a, b: KeyVal[], obj, context, scope) => {\n  let res = {} as any;\n  for (let item of b) {\n    if (item.key instanceof SpreadObject) {\n      res = {...res, ...item.key.item};\n    } else {\n      res[item.key] = item.val;\n    }\n  }\n  done(undefined, res);\n});\n\naddOps(LispType.KeyVal, (exec, done, ticks, a: string, b: LispItem) => done(undefined, new KeyVal(a, b)));\n\naddOps(LispType.CreateArray, (exec, done, ticks, a, b: Lisp[], obj, context, scope) => {\n  const items = b.map((item) => {\n    if (item instanceof SpreadArray) {\n      return [...item.item];\n    } else {\n      return [item];\n    }\n  }).flat().map((item) => valueOrProp(item, context))\n  done(undefined, items)\n});\n\naddOps(LispType.Group, (exec, done, ticks, a, b) => done(undefined, b));\n\naddOps(LispType.GlobalSymbol, (exec, done, ticks, a, b: string) => {\n  switch (b) {\n    case 'true': return done(undefined, true);\n    case 'false': return done(undefined, false);\n    case 'null': return done(undefined, null);\n    case 'undefined': return done(undefined, undefined);\n    case 'NaN': return done(undefined, NaN);\n    case 'Infinity': return done(undefined, Infinity);\n  }\n  done(new Error('Unknown symbol: ' + b))\n})\n\naddOps(LispType.Number, (exec, done, ticks, a, b) => done(undefined, Number(b)));\naddOps(LispType.BigInt, (exec, done, ticks, a, b) => done(undefined, BigInt(b)));\naddOps(LispType.StringIndex, (exec, done, ticks, a, b: string, obj, context) => done(undefined, context.constants.strings[parseInt(b)]));\n\naddOps(LispType.RegexIndex, (exec, done, ticks, a, b: string, obj, context) => {\n  const reg: IRegEx = context.constants.regexes[parseInt(b)];\n  if (!context.ctx.globalsWhitelist.has(RegExp)) {\n    throw new SandboxError(\"Regex not permitted\");\n  } else {\n    done(undefined, new RegExp(reg.regex, reg.flags));\n  }\n});\n\naddOps(LispType.LiteralIndex, (exec, done, ticks, a, b: string, obj, context, scope) => {\n  let item = context.constants.literals[parseInt(b)];\n  const [,name,js] = item;\n  let found: Lisp[] = [];\n  let f: RegExpExecArray;\n  let resnums: string[] = [];\n  while(f = literalRegex.exec(name)) {\n    if (!f[2]) {\n      found.push(js[parseInt(f[3], 10)]);\n      resnums.push(f[3]);\n    }\n  }\n\n  exec(ticks, found, scope, context, (err, processed) => {\n    const reses = {};\n    if(err) {\n      done(err);\n      return;\n    }\n    for (let i in resnums) {\n      const num = resnums[i];\n      reses[num] = processed[i];\n    }\n    done(undefined, name.replace(/(\\\\\\\\)*(\\\\)?\\${(\\d+)}/g, (match, $$, $, num) => {\n      if ($) return match;\n      let res = reses[num];\n      return ($$ ? $$ : '') + `${valueOrProp(res, context)}`;\n    }));\n  })\n});\n\naddOps(LispType.SpreadArray, (exec, done, ticks, a, b, obj, context, scope) => {\n  done(undefined, new SpreadArray(b));\n});\n\naddOps(LispType.SpreadObject, (exec, done, ticks, a, b, obj, context, scope) => {\n  done(undefined, new SpreadObject(b));\n});\n\naddOps(LispType.Not, (exec, done, ticks, a, b) => done(undefined, !b));\naddOps(LispType.Inverse, (exec, done, ticks, a, b) => done(undefined, ~b));\n\naddOps(LispType.IncrementBefore, (exec, done, ticks, a, b, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, ++obj.context[obj.prop]);\n});\n\naddOps(LispType.IncrementAfter, (exec, done, ticks, a, b, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop]++);\n});\n\naddOps(LispType.DecrementBefore, (exec, done, ticks, a, b, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, --obj.context[obj.prop]);\n});\n\naddOps(LispType.DecrementAfter, (exec, done, ticks, a, b, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop]--);\n});\n\naddOps(LispType.Assign, (exec, done, ticks, a, b, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] = b);\n});\n\naddOps(LispType.AddEquals, (exec, done, ticks, a, b, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] += b);\n});\n\naddOps(LispType.SubractEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] -= b);\n});\n\naddOps(LispType.DivideEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] /= b);\n});\n\naddOps(LispType.MultiplyEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] *= b);\n});\n\naddOps(LispType.PowerEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] **= b);\n});\n\naddOps(LispType.ModulusEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] %= b);\n});\n\naddOps(LispType.BitNegateEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] ^= b);\n});\n\naddOps(LispType.BitAndEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] &= b);\n});\n\naddOps(LispType.BitOrEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] |= b);\n});\n\naddOps(LispType.ShiftLeftEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] <<= b);\n});\n\naddOps(LispType.ShiftRightEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] >>= b);\n});\n\naddOps(LispType.UnsignedShiftRightEquals, (exec, done, ticks, a, b: number, obj, context) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop] >>= b);\n});\n\naddOps(LispType.LargerThan, (exec, done, ticks, a, b) => done(undefined, a > b));\naddOps(LispType.SmallerThan, (exec, done, ticks, a, b) => done(undefined, a < b));\naddOps(LispType.LargerEqualThan, (exec, done, ticks, a, b) => done(undefined, a >= b));\naddOps(LispType.SmallerEqualThan, (exec, done, ticks, a, b) => done(undefined, a <= b));\naddOps(LispType.Equal, (exec, done, ticks, a, b) => done(undefined, a == b));\naddOps(LispType.StrictEqual, (exec, done, ticks, a, b) => done(undefined, a === b));\naddOps(LispType.NotEqual, (exec, done, ticks, a, b) => done(undefined, a != b));\naddOps(LispType.StrictNotEqual, (exec, done, ticks, a, b) => done(undefined, a !== b));\naddOps(LispType.And, (exec, done, ticks, a, b) => done(undefined, a && b));\naddOps(LispType.Or, (exec, done, ticks, a, b) => done(undefined, a || b));\naddOps(LispType.BitAnd, (exec, done, ticks, a: number, b: number) => done(undefined, a & b));\naddOps(LispType.BitOr, (exec, done, ticks, a: number, b: number) => done(undefined, a | b));\naddOps(LispType.Plus, (exec, done, ticks, a: number, b: number) => done(undefined, a + b));\naddOps(LispType.Minus, (exec, done, ticks, a: number, b: number) => done(undefined, a - b));\naddOps(LispType.Positive, (exec, done, ticks, a, b) => done(undefined, +b));\naddOps(LispType.Negative, (exec, done, ticks, a, b) => done(undefined, -b));\naddOps(LispType.Divide, (exec, done, ticks, a: number, b: number) => done(undefined, a / b));\naddOps(LispType.BitNegate, (exec, done, ticks, a: number, b: number) => done(undefined, a ^ b));\naddOps(LispType.Multiply, (exec, done, ticks, a: number, b: number) => done(undefined, a * b));\naddOps(LispType.Modulus, (exec, done, ticks, a: number, b: number) => done(undefined, a % b));\naddOps(LispType.BitShiftLeft, (exec, done, ticks, a: number, b: number) => done(undefined, a << b));\naddOps(LispType.BitShiftRight, (exec, done, ticks, a: number, b: number) => done(undefined, a >> b));\naddOps(LispType.BitUnsignedShiftRight, (exec, done, ticks, a: number, b: number) => done(undefined, a >>> b));\naddOps(LispType.Typeof, (exec, done, ticks, a, b: LispItem, obj, context, scope) => {\n    exec(ticks, b, scope, context, (e, prop) => {\n      done(undefined, typeof valueOrProp(prop, context));\n    });\n  });\n\naddOps(LispType.Instanceof, (exec, done, ticks, a, b:  { new(): unknown }) => done(undefined, a instanceof b));\naddOps(LispType.In, (exec, done, ticks, a: string, b) => done(undefined, a in b));\n\naddOps(LispType.Delete, (exec, done, ticks, a, b, obj, context, scope, bobj: Prop) => {\n  if (bobj.context === undefined) {\n    done(undefined, true);\n    return;\n  }\n  assignCheck(bobj, context, 'delete');\n  if (bobj.isVariable) {\n    done(undefined, false);\n    return;\n  }\n  done(undefined, delete bobj.context[bobj.prop]);\n});\n\naddOps(LispType.Return, (exec, done, ticks, a, b, obj, context) => done(undefined, b));\n\naddOps(LispType.Var, (exec, done, ticks, a: string, b: LispItem, obj, context, scope, bobj) => {\n  done(undefined, scope.declare(a, VarType.var, b));\n});\n\naddOps(LispType.Let, (exec, done, ticks, a: string, b: LispItem, obj, context, scope, bobj) => {\n  done(undefined, scope.declare(a, VarType.let, b, bobj && bobj.isGlobal));\n});\n\naddOps(LispType.Const, (exec, done, ticks, a: string, b: LispItem, obj, context, scope, bobj) => {\n  done(undefined, scope.declare(a, VarType.const, b));\n});\n\naddOps(LispType.ArrowFunction, (exec, done, ticks, a: string[], b: Lisp[], obj: Lisp, context, scope) => {\n  a = [...a];\n    if (typeof obj[2] === \"string\" || obj[2] instanceof CodeString) {\n      obj[2] = b = lispifyFunction(new CodeString(obj[2]), context.constants);\n    }\n    if (a.shift()) {\n      done(undefined, createFunctionAsync(a, b, ticks, context, scope));\n    } else {\n      done(undefined, createFunction(a, b, ticks, context, scope));\n    }\n});\n\naddOps(LispType.Function, (exec, done, ticks, a: (string|LispType)[], b: Lisp[], obj: Lisp, context, scope) => {   \n  if (typeof obj[2] === \"string\" || obj[2] instanceof CodeString) {\n    obj[2] = b = lispifyFunction(new CodeString(obj[2]), context.constants);\n  }\n  let isAsync = a.shift();\n  let name = a.shift() as string;\n  let func;\n  if (isAsync === LispType.True) {\n    func = createFunctionAsync(a as string[], b, ticks, context, scope, name);\n  } else {\n    func = createFunction(a as string[], b, ticks, context, scope, name);\n  }\n  if (name) {\n    scope.declare(name, VarType.var, func);\n  }\n  done(undefined, func);\n});\n\naddOps(LispType.InlineFunction, (exec, done, ticks, a: (string|LispType)[], b: Lisp[], obj: Lisp, context, scope) => {\n  if (typeof obj[2] === \"string\" || obj[2] instanceof CodeString) {\n    obj[2] = b = lispifyFunction(new CodeString(obj[2]), context.constants);\n  }\n  let isAsync = a.shift();\n  let name = a.shift() as string;\n  if (name) {\n    scope = new Scope(scope, {})\n  }\n  let func;\n  if (isAsync === LispType.True) {\n    func = createFunctionAsync(a as string[], b, ticks, context, scope, name);\n  } else {\n    func = createFunction(a as string[], b, ticks, context, scope, name);\n  }\n  if (name) {\n    scope.declare(name, VarType.let, func);\n  }\n  done(undefined, func);\n});\n\naddOps(LispType.Loop, (exec, done, ticks, a: Lisp[], b: Lisp[], obj, context, scope) => {\n  const [checkFirst, startInternal, getIterator, startStep, step, condition, beforeStep] = a;\n  let loop = true;\n  const loopScope = new Scope(scope, {});\n  let internalVars = {\n    '$$obj': undefined\n  };\n  const interalScope = new Scope(loopScope, internalVars);\n  if (exec === execAsync) {\n    (async() => {\n      let ad: AsyncDoneRet;\n      ad = asyncDone((d) => exec(ticks, startStep, loopScope, context, d));\n      internalVars['$$obj'] = (ad = asyncDone((d) => exec(ticks, getIterator, loopScope, context, d))).isInstant === true ? ad.instant : (await ad.p).result;\n      ad = asyncDone((d) => exec(ticks, startInternal, interalScope, context, d));\n      if (checkFirst) loop = (ad = asyncDone((d) => exec(ticks, condition, interalScope, context, d))).isInstant === true ? ad.instant : (await ad.p).result;\n      while (loop) {\n        let innerLoopVars = {};\n        ad = asyncDone((d) => exec(ticks, beforeStep, new Scope(interalScope, innerLoopVars), context, d));\n        ad.isInstant === true ? ad.instant : (await ad.p).result;\n        let res = await executeTreeAsync(ticks, context, b, [new Scope(loopScope, innerLoopVars)], \"loop\");\n        if (res instanceof ExecReturn && res.returned) {\n          done(undefined, res);\n          return;\n        }\n        if (res instanceof ExecReturn && res.breakLoop) {\n          break;\n        }\n        ad = asyncDone((d) => exec(ticks, step, interalScope, context, d));\n        loop = (ad = asyncDone((d) => exec(ticks, condition, interalScope, context, d))).isInstant === true ? ad.instant : (await ad.p).result;\n      }\n      done();\n    })().catch(done);\n  } else {\n    syncDone((d) => exec(ticks, startStep, loopScope, context, d));\n    internalVars['$$obj'] = syncDone((d) => exec(ticks, getIterator, loopScope, context, d)).result;\n    syncDone((d) => exec(ticks, startInternal, interalScope, context, d));\n    if (checkFirst) loop = (syncDone((d) => exec(ticks, condition, interalScope, context, d))).result;\n    while (loop) {\n      let innerLoopVars = {};\n      syncDone((d) => exec(ticks, beforeStep, new Scope(interalScope, innerLoopVars), context, d));\n      let res = executeTree(ticks, context, b, [new Scope(loopScope, innerLoopVars)], \"loop\");\n      if (res instanceof ExecReturn && res.returned) {\n        done(undefined, res);\n        return;\n      }\n      if (res instanceof ExecReturn && res.breakLoop) {\n        break;\n      }\n      syncDone((d) => exec(ticks, step, interalScope, context, d));\n      loop = (syncDone((d) => exec(ticks, condition, interalScope, context, d))).result;\n    }\n    done();\n  }\n});\n\naddOps(LispType.LoopAction, (exec, done, ticks, a: LispItem, b: LispItem, obj, context, scope, bobj, inLoopOrSwitch) => {\n  if ((inLoopOrSwitch === \"switch\" && a === \"continue\") || !inLoopOrSwitch) {\n    throw new SandboxError(\"Illegal \" + a + \" statement\");\n  }\n  done(undefined, new ExecReturn(context.ctx.auditReport, undefined, false, a === \"break\", a === \"continue\"));\n});\n\naddOps(LispType.If, (exec, done, ticks, a: LispItem, b:If, obj, context, scope, bobj, inLoopOrSwitch) => {\n  exec(ticks, valueOrProp(a, context) ? b.t : b.f, scope, context, done);\n});\n\naddOps(LispType.InlineIf, (exec, done, ticks, a: LispItem, b: If, obj, context, scope) => {\n  exec(ticks, valueOrProp(a, context) ? b.t : b.f, scope, context, done);\n});\naddOps(LispType.InlineIfCase, (exec, done, ticks, a, b) => done(undefined, new If(a, b)));\naddOps(LispType.IfCase, (exec, done, ticks, a, b) => done(undefined, new If(a, b)));\n\naddOps(LispType.Switch, (exec, done, ticks, a: LispItem, b: SwitchCase[], obj, context, scope) => {\n  exec(ticks, a, scope, context, (err, toTest) => {\n    if (err) {\n      done(err);\n      return;\n    }\n    toTest = valueOrProp(toTest, context);\n    if (exec === execSync) {\n      let res: ExecReturn<unknown>;\n      let isTrue = false;\n      for (let caseItem of b) {\n        if (isTrue || (isTrue = !caseItem[1] || toTest === valueOrProp((syncDone((d) => exec(ticks, caseItem[1], scope, context, d))).result, context))) {\n          if (!caseItem[2]) continue;\n          res = executeTree(ticks, context, caseItem[2], [scope], \"switch\");\n          if (res.breakLoop) break;\n          if (res.returned) {\n            done(undefined, res);\n            return;\n          }\n          if (!caseItem[1]) { // default case\n            break;\n          }\n        }\n      }\n      done();\n    } else {\n      (async () => {\n        let res: ExecReturn<unknown>;\n        let isTrue = false;\n        for (let caseItem of b) {\n          let ad: AsyncDoneRet;\n          if (isTrue || (isTrue = !caseItem[1] || toTest === valueOrProp((ad = asyncDone((d) => exec(ticks, caseItem[1], scope, context, d))).isInstant === true ? ad.instant : (await ad.p).result, context))) {\n            if (!caseItem[2]) continue;\n            res = await executeTreeAsync(ticks, context, caseItem[2], [scope], \"switch\");\n            if (res.breakLoop) break;\n            if (res.returned) {\n              done(undefined, res);\n              return;\n            }\n            if (!caseItem[1]) { // default case\n              break;\n            }\n          }\n        }\n        done();\n      })().catch(done)\n    }\n  });\n});\n\naddOps(LispType.Try, (exec, done, ticks, a: Lisp[], b: [string, Lisp[], Lisp[]], obj, context, scope, bobj, inLoopOrSwitch) => {\n  const [exception, catchBody, finallyBody] = b;\n  executeTreeWithDone(exec, (err, res) => {\n    executeTreeWithDone(exec, (e) => {\n      if (e) done(e);\n      else  if (err) {\n        let sc = {};\n        if (exception) sc[exception] = err;\n        executeTreeWithDone(exec, done, ticks, context, catchBody, [new Scope(scope)], inLoopOrSwitch);\n      } else {\n        done(undefined, res);\n      }\n    }, ticks, context, finallyBody, [new Scope(scope, {})]);\n  }, ticks, context, a, [new Scope(scope)], inLoopOrSwitch);\n});\n\naddOps(LispType.Void, (exec, done, ticks, a) => {done()});\naddOps(LispType.New, (exec, done, ticks, a: new (...args: unknown[]) => unknown, b: unknown[], obj, context) => {\n  if (!context.ctx.globalsWhitelist.has(a) && !sandboxedFunctions.has(a)) {\n    throw new SandboxError(`Object construction not allowed: ${a.constructor.name}`)\n  }\n  done(undefined, new a(...b))\n});\n\naddOps(LispType.Throw, (exec, done, ticks, a, b) => { done(b) });\naddOps(LispType.Expression, (exec, done, ticks, a: unknown[]) => done(undefined, a.pop()));\naddOps(LispType.None, (exec, done, ticks, a: unknown[]) => done());\n\nfunction valueOrProp(a: unknown, context: IExecContext): any {\n  if (a instanceof Prop) return a.get(context);\n  if (a === optional) return undefined;\n  return a;\n}\n\nexport function execMany(ticks: Ticks, exec: Execution, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string) {\n  if (exec === execSync) {\n    _execManySync(ticks, tree, done, scope, context, inLoopOrSwitch);\n  } else {\n    _execManyAsync(ticks, tree, done, scope, context, inLoopOrSwitch).catch(done);\n  }\n}\n\nfunction _execManySync(ticks: Ticks, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string) {\n  let ret = [];\n  for (let i = 0; i < tree.length; i++) {\n    let res;\n    try {\n      res = syncDone((d) => execSync(ticks, tree[i], scope, context, d, inLoopOrSwitch)).result;\n    } catch(e) {\n      done(e);\n      return;\n    }\n    if (res instanceof ExecReturn && (res.returned || res.breakLoop || res.continueLoop)) {\n      done(undefined, res);\n      return;\n    }\n    if (isLisp(tree[i]) && tree[i][0] === LispType.Return) {\n      done(undefined, new ExecReturn(context.ctx.auditReport, res, true))\n      return;\n    }\n    ret.push(res);\n  }\n  done(undefined, ret);\n}\n\nasync function _execManyAsync(ticks: Ticks, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string) {\n  let ret = [];\n  for (let i = 0; i < tree.length; i++) {\n    let res;\n    try {\n      let ad: AsyncDoneRet;\n      res = (ad = asyncDone((d) => execAsync(ticks, tree[i], scope, context, d, inLoopOrSwitch))).isInstant === true ? ad.instant : (await ad.p).result;\n    } catch(e) {\n      done(e);\n      return;\n    }\n    if (res instanceof ExecReturn && (res.returned || res.breakLoop || res.continueLoop)) {\n      done(undefined, res);\n      return;\n    }\n    if (isLisp(tree[i]) && tree[i][0] === LispType.Return) {\n      done(undefined, new ExecReturn(context.ctx.auditReport, res, true))\n      return;\n    }\n    ret.push(res);\n  }\n  done(undefined, ret);\n}\n\ntype Execution = (ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done, inLoopOrSwitch?: string) => void\n\nexport interface AsyncDoneRet {\n  isInstant: boolean,\n  instant: any,\n  p: Promise<{result: any}>\n}\n\nexport function asyncDone(callback: (done: Done) => void): AsyncDoneRet {\n  let isInstant = false;\n  let instant: unknown;\n  const p = new Promise<any>((resolve, reject) => {\n    callback((err, result) => {\n      if (err) reject(err);\n      else {\n        isInstant = true;\n        instant = result;\n        resolve({result})\n      };\n    });\n  });\n  return {\n    isInstant,\n    instant,\n    p\n  }\n}\n\nexport function syncDone(callback: (done: Done) => void): {result: any} {\n  let result;\n  let err;\n  callback((e, r) => {\n    err = e;\n    result = r;\n  });\n  if (err) throw err;\n  return {result};\n}\n\nexport async function execAsync(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, doneOriginal: Done, inLoopOrSwitch?: string): Promise<void> {\n  let done: Done = doneOriginal;\n  const p = new Promise<void>((resolve) => {\n    done = (e, r?) => {\n      doneOriginal(e, r);\n      resolve();\n    }\n  });\n  if(_execNoneRecurse(ticks, tree, scope, context, done, true, inLoopOrSwitch)) {\n  } else if (isLisp(tree)) {\n    let op = tree[0];\n    let obj;\n    try {\n      let ad: AsyncDoneRet;\n      obj = (ad = asyncDone((d) => execAsync(ticks, tree[1], scope, context, d, inLoopOrSwitch))).isInstant === true ? ad.instant : (await ad.p).result;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    let a = obj;\n    try {\n      a = obj instanceof Prop ? obj.get(context) : obj;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    if (op === LispType.PropOptional || op === LispType.CallOptional) {\n      if (a === undefined || a === null) {\n        done(undefined, optional);\n        return;\n      }\n      op = op === LispType.PropOptional ? LispType.Prop : LispType.Call;\n    }\n    if (a === optional) {\n      if (op === LispType.Prop || op === LispType.Call) {\n        done(undefined, a);\n        return;\n      } else {\n        a = undefined;\n      }\n    }\n    let bobj;\n    try {\n      let ad: AsyncDoneRet;\n      bobj = (ad = asyncDone((d) => execAsync(ticks, tree[2], scope, context, d, inLoopOrSwitch))).isInstant === true ? ad.instant : (await ad.p).result;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    let b = bobj;\n    try {\n      b = bobj instanceof Prop ? bobj.get(context) : bobj;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    if (b === optional) {\n      b = undefined;\n    }\n    if (ops.has(op)) {\n      try {\n        ops.get(op)(execAsync, done, ticks, a, b, obj, context, scope, bobj, inLoopOrSwitch);\n      } catch (err) {\n        done(err);\n      }\n    } else {\n      done(new SyntaxError('Unknown operator: ' + op));\n    }\n  }\n  await p;\n}\n\n\nexport function execSync(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done, inLoopOrSwitch?: string) {\n  if(_execNoneRecurse(ticks, tree, scope, context, done, false, inLoopOrSwitch)) {\n  } else if (isLisp(tree)) {\n    let op = tree[0];\n    let obj;\n    try {\n      obj = syncDone((d) => execSync(ticks, tree[1], scope, context, d, inLoopOrSwitch)).result;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    let a = obj;\n    try {\n      a = obj instanceof Prop ? obj.get(context) : obj;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    if (op === LispType.PropOptional || op === LispType.CallOptional) {\n      if (a === undefined || a === null) {\n        done(undefined, optional);\n        return;\n      }\n      op = op === LispType.PropOptional ? LispType.Prop : LispType.Call;\n    }\n    if (a === optional) {\n      if (op === LispType.Prop || op === LispType.Call) {\n        done(undefined, a);\n        return;\n      } else {\n        a = undefined;\n      }\n    }\n    let bobj;\n    try {\n      bobj = syncDone((d) => execSync(ticks, tree[2], scope, context, d, inLoopOrSwitch)).result;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    let b = bobj;\n    try {\n      b = bobj instanceof Prop ? bobj.get(context) : bobj;\n    } catch (e) {\n      done(e);\n      return;\n    }\n    if (b === optional) {\n      b = undefined;\n    }\n    if (ops.has(op)) {\n      try {\n        ops.get(op)(execSync, done, ticks, a, b, obj, context, scope, bobj, inLoopOrSwitch);\n      } catch (err) {\n        done(err);\n      }\n    } else {\n      done(new SyntaxError('Unknown operator: ' + op));\n    }\n  }\n}\n\nconst unexecTypes = new Set([\n  LispType.ArrowFunction,\n  LispType.Function,\n  LispType.InlineFunction,\n  LispType.Loop,\n  LispType.Try,\n  LispType.Switch,\n  LispType.IfCase,\n  LispType.InlineIfCase,\n  LispType.Typeof\n]);\n\nfunction _execNoneRecurse(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done, isAsync: boolean, inLoopOrSwitch?: string): boolean {\n  const exec = isAsync ? execAsync : execSync;\n  if (context.ctx.options.executionQuota <= ticks.ticks) {\n    if (typeof context.ctx.options.onExecutionQuotaReached === 'function' && context.ctx.options.onExecutionQuotaReached(ticks, scope, context, tree)) {\n    } else {\n      done(new SandboxError(\"Execution quota exceeded\"));\n      return;\n    }\n  }\n  ticks.ticks++;\n  currentTicks = ticks;\n  if (tree instanceof Prop) {\n    try {\n      done(undefined, tree.get(context));\n    } catch (err) {\n      done(err);\n    }\n  } else if (tree === optional) {\n    done();\n  } else if (Array.isArray(tree) && !isLisp(tree)) {\n    if (tree[0] === LispType.None) {\n      done();\n    } else {\n      execMany(ticks, exec, tree as Lisp[], done, scope, context, inLoopOrSwitch);\n    }\n  } else if (!isLisp(tree)) {\n    done(undefined, tree);\n  } else if (tree[0] === LispType.Block) {\n    execMany(ticks, exec, tree[1] as Lisp[], done, scope, context, inLoopOrSwitch);\n  } else if (tree[0] === LispType.Await) {\n    if (!isAsync) {\n      done(new SandboxError(\"Illegal use of 'await', must be inside async function\"));\n    } else if (context.ctx.prototypeWhitelist?.has(Promise.prototype)) {\n      execAsync(ticks, tree[1], scope, context, async (e, r) => {\n        if (e) done(e);\n        else try {\n          done(undefined, await valueOrProp(r, context));\n        } catch(err) {\n          done(err);\n        }\n      }, inLoopOrSwitch).catch(done);\n    } else {\n      done(new SandboxError('Async/await is not permitted'))\n    }\n  } else if (unexecTypes.has(tree[0])) {\n    try {\n      ops.get(tree[0])(exec, done, ticks, tree[1], tree[2], tree, context, scope, undefined, inLoopOrSwitch);\n    } catch (err) {\n      done(err);\n    }\n  } else {\n    return false;\n  }\n  return true;\n}\nexport function executeTree<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes: (IScope)[] = [], inLoopOrSwitch?: string): ExecReturn<T> {\n  return syncDone((done) => executeTreeWithDone(execSync, done, ticks, context, executionTree, scopes, inLoopOrSwitch)).result;\n}\n\nexport async function executeTreeAsync<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes: (IScope)[] = [], inLoopOrSwitch?: string): Promise<ExecReturn<T>> {\n  let ad: AsyncDoneRet;\n  return (ad = asyncDone((done) => executeTreeWithDone(execAsync, done, ticks, context, executionTree, scopes, inLoopOrSwitch))).isInstant === true ? ad.instant : (await ad.p).result;\n}\n\nfunction executeTreeWithDone(exec: Execution, done: Done, ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes: (IScope)[] = [], inLoopOrSwitch?: string) {\n  if (!executionTree)  {\n    done();\n    return;\n  }\n  if (!(executionTree instanceof Array)) {\n    throw new SyntaxError('Bad execution tree');\n  }\n  let scope = context.ctx.globalScope;\n  let s;\n  while (s = scopes.shift()) {\n    if (typeof s !== \"object\") continue;\n    if (s instanceof Scope) {\n      scope = s;\n    } else {\n      scope = new Scope(scope, s, s instanceof LocalScope ? undefined : null);\n    }\n  }\n  if (context.ctx.options.audit && !context.ctx.auditReport) {\n    context.ctx.auditReport = {\n      globalsAccess: new Set(),\n      prototypeAccess: {},\n    }\n  }\n  if (exec === execSync) {\n    _executeWithDoneSync(done, ticks, context, executionTree, scope, inLoopOrSwitch);\n  } else {\n    _executeWithDoneAsync(done, ticks, context, executionTree, scope, inLoopOrSwitch).catch(done);\n  }\n}\n\nfunction _executeWithDoneSync(done: Done, ticks: Ticks, context: IExecContext, executionTree: Lisp[], scope: Scope, inLoopOrSwitch?: string) {\n  if (!(executionTree instanceof Array)) throw new SyntaxError('Bad execution tree');\n  let i = 0;\n  for (i = 0; i < executionTree.length; i++) {\n    let res;\n    let err;\n    const current = executionTree[i];\n    try {\n      execSync(ticks, current, scope, context, (e, r) => {\n        err = e;\n        res = r;\n      }, inLoopOrSwitch);\n    } catch (e) {\n      err = e;\n    }\n    if (err) {\n      done(err);\n      return;\n    }\n    if (res instanceof ExecReturn) {\n      done(undefined, res);\n      return;\n    }\n    if (isLisp(current) && current[0] === LispType.Return) {\n      done(undefined, new ExecReturn(context.ctx.auditReport, res, true))\n      return;\n    }\n  }\n  done(undefined, new ExecReturn(context.ctx.auditReport, undefined, false));\n}\n\nasync function _executeWithDoneAsync(done: Done, ticks: Ticks, context: IExecContext, executionTree: Lisp[], scope: Scope, inLoopOrSwitch?: string) {\n  if (!(executionTree instanceof Array)) throw new SyntaxError('Bad execution tree');\n  let i = 0;\n  for (i = 0; i < executionTree.length; i++) {\n    let res;\n    let err;\n    const current = executionTree[i];\n    try {\n      await execAsync(ticks, current, scope, context, (e, r) => {\n        err = e;\n        res = r;\n      }, inLoopOrSwitch);\n    } catch (e) {\n      err = e;\n    }\n    if (err) {\n      done(err);\n      return;\n    }\n    if (res instanceof ExecReturn) {\n      done(undefined, res);\n      return;\n    }\n    if (isLisp(current) && current[0] === LispType.Return) {\n      done(undefined, new ExecReturn(context.ctx.auditReport, res, true))\n      return;\n    }\n  }\n  done(undefined, new ExecReturn(context.ctx.auditReport, undefined, false));\n}\n","import { \n  IGlobals, \n  IAuditReport,  \n  Change, \n  sandboxFunction,\n  sandboxedEval,\n  sandboxedSetTimeout,\n  sandboxedSetInterval,\n  ExecReturn,\n  executeTree,\n  executeTreeAsync,\n  ops,\n  assignCheck,\n  execMany,\n  execAsync,\n  execSync,\n  asyncDone,\n  Scope,\n  IScope,\n  FunctionScope,\n  LocalScope,\n  syncDone\n} from \"./executor.js\";\nimport { parse, IExecutionTree, expectTypes, setLispType, LispItem, IConstants, Lisp } from \"./parser.js\";\n\ntype replacementCallback = (obj: any, isStaticAccess: boolean) => any\n\nexport {\n  expectTypes,\n  setLispType,\n  ops as executionOps,\n  assignCheck,\n  execMany,\n  execAsync,\n  execSync,\n  asyncDone,\n  syncDone,\n  executeTree,\n  executeTreeAsync,\n  FunctionScope,\n  LocalScope,\n};\n\nexport interface IOptions {\n  audit?: boolean;\n  forbidFunctionCalls?: boolean;\n  forbidFunctionCreation?: boolean;\n  prototypeReplacements?: Map<new () => any, replacementCallback>;\n  prototypeWhitelist?: Map<any, Set<string>>;\n  globals: IGlobals;\n  executionQuota?: bigint;\n  onExecutionQuotaReached?: (ticks: Ticks, scope: Scope, context: IExecutionTree, tree: LispItem) => boolean|void;\n}\n\nexport interface IContext {\n  sandbox: Sandbox;\n  globalScope: Scope;\n  sandboxGlobal: SandboxGlobal;\n  globalsWhitelist?: Set<any>;\n  prototypeWhitelist?: Map<any, Set<string>>;\n  options: IOptions;\n  auditReport?: IAuditReport;\n}\n\nexport interface Ticks {\n  ticks: bigint;\n}\n\nexport interface IExecContext extends IExecutionTree {\n  ctx: IContext,\n  getSubscriptions: Set<(obj: object, name: string) => void>;\n  setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;\n  changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>;\n  setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;\n  changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>;\n  registerSandboxFunction: (fn: (...args: any[]) => any) => void;\n  evals: Map<any, any>;\n}\n\nexport class SandboxGlobal {\n  constructor(globals: IGlobals) {\n    if (globals === globalThis) return globalThis;\n    for (let i in globals) {\n      (this as any)[i] = globals[i];\n    }\n  }\n}\n\nexport class ExecContext implements IExecContext {\n  constructor(\n    public ctx: IContext,\n    public constants: IConstants,\n    public tree: Lisp[],\n    public getSubscriptions: Set<(obj: object, name: string) => void>,\n    public setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>,\n    public changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>,\n    public setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>,\n    public changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>,\n    public evals: Map<any, any>,\n    public registerSandboxFunction: (fn: (...args: any[]) => any) => void\n  ) {\n\n  }\n}\n\nfunction subscribeSet(obj: object, name: string, callback: (modification: Change) => void, context: {\n  setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, \n  changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>\n}): {unsubscribe: () => void} {\n  const names = context.setSubscriptions.get(obj) || new Map<string, Set<(modification: Change) => void>>();\n  context.setSubscriptions.set(obj, names);\n  const callbacks = names.get(name) || new Set();\n  names.set(name, callbacks);\n  callbacks.add(callback);\n  let changeCbs: Set<(modification: Change) => void>;\n  if (obj && obj[name] && typeof obj[name] === \"object\") {\n    changeCbs = context.changeSubscriptions.get(obj[name]) || new Set();\n    changeCbs.add(callback);\n    context.changeSubscriptions.set(obj[name], changeCbs);\n  }\n  return {\n    unsubscribe: () => {\n      callbacks.delete(callback);\n      changeCbs?.delete(callback);\n    }\n  }\n}\n\n\nexport default class Sandbox {\n  context: IContext;\n  setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>> = new WeakMap();\n  changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>> = new WeakMap();\n  sandboxFunctions: WeakMap<(...args: any[]) => any, IExecContext> = new WeakMap();\n  constructor(options?: IOptions) {\n    options = Object.assign({\n      audit: false,\n      forbidFunctionCalls: false,\n      forbidFunctionCreation: false,\n      globals: Sandbox.SAFE_GLOBALS,\n      prototypeWhitelist: Sandbox.SAFE_PROTOTYPES, \n      prototypeReplacements: new Map<new() => any, replacementCallback>(),\n    }, options || {});\n    const sandboxGlobal = new SandboxGlobal(options.globals);\n    this.context = {\n      sandbox: this,\n      globalsWhitelist: new Set(Object.values(options.globals)),\n      prototypeWhitelist: new Map([...options.prototypeWhitelist].map((a) => [a[0].prototype, a[1]])),\n      options,\n      globalScope: new Scope(null, options.globals, sandboxGlobal),\n      sandboxGlobal\n    };\n    this.context.prototypeWhitelist.set(Object.getPrototypeOf([][Symbol.iterator]()), new Set());\n  }\n\n  static get SAFE_GLOBALS(): IGlobals {\n    return {\n      Function,\n      console: {\n        debug: console.debug, \n        error: console.error, \n        info: console.info, \n        log: console.log, \n        table: console.table, \n        warn: console.warn\n      },\n      isFinite,\n      isNaN,\n      parseFloat,\n      parseInt,\n      decodeURI,\n      decodeURIComponent,\n      encodeURI,\n      encodeURIComponent,\n      escape,\n      unescape,\n      Boolean,\n      Number,\n      BigInt,\n      String,\n      Object,\n      Array,\n      Symbol,\n      Error,\n      EvalError,\n      RangeError,\n      ReferenceError,\n      SyntaxError,\n      TypeError,\n      URIError,\n      Int8Array,\n      Uint8Array,\n      Uint8ClampedArray,\n      Int16Array,\n      Uint16Array,\n      Int32Array,\n      Uint32Array,\n      Float32Array,\n      Float64Array,\n      Map,\n      Set,\n      WeakMap,\n      WeakSet,\n      Promise,\n      Intl,\n      JSON,\n      Math,\n      Date,\n      RegExp\n    }\n  }\n\n  \n  static get SAFE_PROTOTYPES(): Map<any, Set<string>> {\n    let protos = [\n      SandboxGlobal,\n      Function,\n      Boolean,\n      Number,\n      BigInt,\n      String,\n      Date,\n      Error,\n      Array,\n      Int8Array,\n      Uint8Array,\n      Uint8ClampedArray,\n      Int16Array,\n      Uint16Array,\n      Int32Array,\n      Uint32Array,\n      Float32Array,\n      Float64Array,\n      Map,\n      Set,\n      WeakMap,\n      WeakSet,\n      Promise,\n      Symbol,\n      Date,\n      RegExp\n    ]\n    let map = new Map<any, Set<string>>();\n    protos.forEach((proto) => {\n      map.set(proto, new Set());\n    });\n    map.set(Object, new Set([\n      'entries',\n      'fromEntries',\n      'getOwnPropertyNames',\n      'is',\n      'keys',\n      'hasOwnProperty',\n      'isPrototypeOf',\n      'propertyIsEnumerable',\n      'toLocaleString',\n      'toString',\n      'valueOf',\n      'values'\n    ]));\n    return map;\n  }\n\n  subscribeGet(callback: (obj: object, name: string) => void, context: IExecContext): {unsubscribe: () => void} {\n    context.getSubscriptions.add(callback);\n    return {unsubscribe: () => context.getSubscriptions.delete(callback)}\n  }\n\n  subscribeSet(obj: object, name: string, callback: (modification: Change) => void, context: Sandbox|IExecContext): {unsubscribe: () => void} {\n    return subscribeSet(obj, name, callback, context);\n  }\n\n  subscribeSetGlobal(obj: object, name: string, callback: (modification: Change) => void): {unsubscribe: () => void} {\n    return subscribeSet(obj, name, callback, this);\n  }\n\n  static audit<T>(code: string, scopes: (IScope)[] = []): ExecReturn<T> {\n    const globals = {};\n    for (let i of Object.getOwnPropertyNames(globalThis)) {\n      globals[i] = globalThis[i];\n    }\n    const sandbox = new Sandbox({\n      globals,\n      audit: true,\n    });\n    return sandbox.executeTree(sandbox.createContext(sandbox.context, parse(code)), scopes);\n  }\n\n  static parse(code: string) {\n    return parse(code);\n  }\n\n  createContext(context: IContext, executionTree: IExecutionTree) {\n    const evals = new Map();\n    const execContext = new ExecContext(\n      context,\n      executionTree.constants,\n      executionTree.tree,\n      new Set<(obj: object, name: string) => void>(),\n      new WeakMap<object, Map<string, Set<(modification: Change) => void>>>(),\n      new WeakMap<object, Set<(modification: Change) => void>>(),\n      this.setSubscriptions,\n      this.changeSubscriptions,\n      evals,\n      (fn) => this.sandboxFunctions.set(fn, execContext)\n    );\n    const func = sandboxFunction(execContext);\n    evals.set(Function, func);\n    evals.set(eval, sandboxedEval(func));\n    evals.set(setTimeout, sandboxedSetTimeout(func));\n    evals.set(setInterval, sandboxedSetInterval(func));\n    return execContext;\n  }\n\n  getContext(fn: (...args: any[]) => any) {\n    return this.sandboxFunctions.get(fn);\n  }\n\n  executeTree<T>(context: IExecContext, scopes: (IScope)[] = []): ExecReturn<T> {\n    return executeTree({\n      ticks: BigInt(0),\n    }, context, context.tree, scopes);\n  }\n\n  executeTreeAsync<T>(context: IExecContext, scopes: (IScope)[] = []): Promise<ExecReturn<T>> {\n    return executeTreeAsync({\n      ticks: BigInt(0),\n    }, context, context.tree, scopes);\n  }\n  \n  compile<T>(code: string, optimize = false): (...scopes: (IScope)[]) => {context: IExecContext, run: () => T} {\n    const parsed = parse(code, optimize);\n    const exec = (...scopes: (IScope)[]) => {\n      const context = this.createContext(this.context, parsed);\n      return {context , run: () => this.executeTree<T>(context, [...scopes]).result};\n    };\n    return exec;\n  };\n  \n  compileAsync<T>(code: string, optimize = false): (...scopes: (IScope)[]) => {context: IExecContext, run: () => Promise<T>} {\n    const parsed = parse(code, optimize);\n    const exec = (...scopes: (IScope)[]) => {\n      const context = this.createContext(this.context, parsed);\n      return {context , run: () => this.executeTreeAsync<T>(context, [...scopes]).then((ret) => ret.result)};\n    };\n    return exec;\n  };\n\n  compileExpression<T>(code: string, optimize = false): (...scopes: (IScope)[]) => {context: IExecContext, run: () => T} {\n    const parsed = parse(code, optimize, true);\n    const exec = (...scopes: (IScope)[]) => {\n      const context = this.createContext(this.context, parsed);\n      return {context , run: () => this.executeTree<T>(context, [...scopes]).result};\n    };\n    return exec\n  }\n\n  compileExpressionAsync<T>(code: string, optimize = false): (...scopes: (IScope)[]) => {context: IExecContext, run: () => Promise<T>} {\n    const parsed = parse(code, optimize, true);\n    const exec = (...scopes: (IScope)[]) => {\n      const context = this.createContext(this.context, parsed);\n      return {context , run: () => this.executeTreeAsync<T>(context, [...scopes]).then((ret) => ret.result)};\n    };\n    return exec;\n  }\n}\n"],"names":["parseHexToInt","hex","match","parseInt","NaN","validateAndParseHex","errorName","enforcedLength","parsedHex","Number","isNaN","undefined","length","SyntaxError","parseHexadecimalCode","code","parsedCode","String","fromCharCode","parseUnicodeCode","surrogateCode","parsedSurrogateCode","isCurlyBraced","text","charAt","parseUnicodeCodePointCode","codePoint","slice","fromCodePoint","err","RangeError","singleCharacterEscapes","Map","parseSingleCharacterCode","get","escapeMatch","unraw","raw","replace","_","backslash","unicodeWithSurrogate","surrogate","unicode","octal","singleCharacter","createLisp","obj","op","a","b","lispTypes","ParseError","Error","constructor","message","super","substring","this","inlineIfElse","elseIf","ifElse","space","expectTypes","splitter","types","opHigh","comparitor","boolOp","bitwise","next","inlineIf","assignment","assignModify","assign","incrementerBefore","expEdge","call","incrementerAfter","modifier","not","inverse","negative","positive","typeof","delete","dot","arrayProp","prop","value","createObject","createArray","number","string","literal","regex","boolean","null","und","arrowFunctionSingle","arrowFunction","inlineFunction","group","Infinity","void","await","new","initialize","return","throw","spreadObject","spreadArray","expEnd","expFunction","function","expSingle","for","do","while","loopAction","if","try","block","switch","closings","testMultiple","str","tests","found","i","exec","CodeString","ref","start","end","len","char","toString","trimStart","trim","valueOf","emptyString","okFirstChars","aNumber","wordReg","semiColon","insertedSemicolons","WeakMap","quoteCache","restOfExp","constants","part","quote","firstOpening","closingsTests","details","words","isStart","hasSemiTest","includes","filter","insertedSemis","cache","set","has","escape","done","lastChar","isOneLiner","lastInertedSemi","skip","regRes","foundWord","foundNumber","sub","push","lastAnyWord","lastWord","test","oneliner","startingExecpted","setLispType","fn","forEach","type","closingsCreate","typesCreate","res","expect","ctx","extract","arg","l","funcFound","lispifyExpr","map","e","lispify","key","lisptype","lispTree","modifierTypes","incrementTypes","adderTypes","instanceof","in","opTypes","extractIfElse","foundTrue","elseReg","count","foundElse","first","f","startsWith","all","Math","max","true","false","quoteCount","condition","ie","startTrue","trueBlock","elseBlock","lispifyBlock","indexOf","caseFound","statement","insertSemicolons","caseTest","cases","defaultFound","cond","bracketFound","exprs","notEmpty","index","matches","lt","isArrow","isReturn","argPos","isAsync","args","split","unshift","ended","func","eager","lispifyFunction","iteratorRegex","getIterator","body","startStep","startInternal","beforeStep","checkFirst","step","lispifyReturnExpr","iterator","extract2","k","ofStart2","ofStart3","ofCondition","ofStep","inStart2","inStart3","inStep","inCondition","shift","isBlock","catchReg","finallyBody","catchBody","catchRes","exception","offset","argsString","j","lastType","expected","topLevel","startingExpectedWithoutSingle","r","subExpressions","pos","Object","values","defined","expression","parts","skipped","isInserted","tree","hoisted","hoist","concat","isLisp","item","Array","isArray","rep","it","closingsNoInsertion","colonsRegex","rest","inserted","valid","edge","checkRegex","cancel","after","flags","notDivide","possibleDivide","extractConstants","currentEnclosure","regexFound","comment","commentStart","currJs","strRes","enclosures","isPossibleDivide","li","join","tempJsStrings","literals","strings","pop","regexes","parse","js","ExecReturn","auditReport","result","returned","breakLoop","continueLoop","Prop","context","isConst","isGlobal","isVariable","ReferenceError","getSubscriptions","cb","optional","reservedWords","Set","VarType","keysOnly","ret","Scope","parent","vars","functionThis","const","let","var","isFuncScope","allVars","globals","functionScope","hasOwnProperty","val","TypeError","SandboxError","declare","FunctionScope","LocalScope","currentTicks","sandboxFunction","ticks","SandboxFunction","params","parsed","createFunction","generateArgs","argNames","sandboxedFunctions","WeakSet","scope","name","options","forbidFunctionCreation","executeTree","registerSandboxFunction","add","createFunctionAsync","prototypeWhitelist","Promise","prototype","async","executeTreeAsync","sandboxedEval","sandboxedSetTimeout","handler","setTimeout","sandboxedSetInterval","setInterval","assignCheck","changeSubscriptions","changeSubscriptionsGlobal","setSubscriptions","setSubscriptionsGlobal","arrayChange","splice","reverse","sort","copyWithin","KeyVal","SpreadObject","SpreadArray","If","t","literalRegex","ops","addOps","valueOrProp","execMany","inLoopOrSwitch","execSync","_execManySync","_execManyAsync","catch","syncDone","d","ad","asyncDone","execAsync","isInstant","instant","p","callback","resolve","reject","doneOriginal","_execNoneRecurse","bobj","sandboxGlobal","audit","globalsAccess","globalsWhitelist","evals","globalThis","globalScope","Boolean","isFunction","prototypeAccess","prot","getPrototypeOf","whitelist","prototypeReplacements","size","constuctor","g","forbidFunctionCalls","vals","flat","JSON","stringify","recurse","x","y","change","changed","added","removed","startIndex","deleteCount","min","endIndex","BigInt","reg","RegExp","resnums","processed","reses","num","$$","$","loop","loopScope","internalVars","$$obj","interalScope","innerLoopVars","toTest","isTrue","caseItem","executeTreeWithDone","unexecTypes","executionQuota","onExecutionQuotaReached","executionTree","scopes","s","_executeWithDoneSync","_executeWithDoneAsync","current","SandboxGlobal","ExecContext","subscribeSet","names","callbacks","changeCbs","unsubscribe","Sandbox","sandboxFunctions","SAFE_GLOBALS","SAFE_PROTOTYPES","sandbox","Symbol","Function","console","debug","error","info","log","table","warn","isFinite","parseFloat","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","unescape","EvalError","URIError","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","Intl","Date","protos","proto","subscribeGet","subscribeSetGlobal","static","getOwnPropertyNames","createContext","execContext","eval","getContext","compile","optimize","run","compileAsync","then","compileExpression","compileExpressionAsync"],"mappings":"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"}
+{"version":3,"file":"Sandbox.js","sources":["../src/eval.ts","../src/Sandbox.ts"],"sourcesContent":["import { createFunction, currentTicks } from './executor.js';\nimport parse, { lispifyFunction } from './parser.js';\nimport { IExecContext, Ticks } from './utils.js';\n\nexport interface IEvalContext {\n  sandboxFunction: typeof sandboxFunction;\n  sandboxedEval: typeof sandboxedEval;\n  sandboxedSetTimeout: typeof sandboxedSetTimeout;\n  sandboxedSetInterval: typeof sandboxedSetInterval;\n  lispifyFunction: typeof lispifyFunction;\n}\nexport type SandboxFunction = (code: string, ...args: string[]) => () => unknown;\nexport type SandboxEval = (code: string) => unknown;\nexport type SandboxSetTimeout = (\n  handler: TimerHandler,\n  timeout?: number,\n  ...args: unknown[]\n) => any;\nexport type SandboxSetInterval = (\n  handler: TimerHandler,\n  timeout?: number,\n  ...args: unknown[]\n) => any;\n\nexport function createEvalContext(): IEvalContext {\n  return {\n    sandboxFunction,\n    sandboxedEval,\n    sandboxedSetTimeout,\n    sandboxedSetInterval,\n    lispifyFunction,\n  };\n}\n\nexport function sandboxFunction(context: IExecContext, ticks?: Ticks): SandboxFunction {\n  return SandboxFunction;\n  function SandboxFunction(...params: string[]) {\n    const code = params.pop() || '';\n    const parsed = parse(code);\n    return createFunction(\n      params,\n      parsed.tree,\n      ticks || currentTicks.current,\n      {\n        ...context,\n        constants: parsed.constants,\n        tree: parsed.tree,\n      },\n      undefined,\n      'anonymous'\n    );\n  }\n}\n\nexport function sandboxedEval(func: SandboxFunction): SandboxEval {\n  return sandboxEval;\n  function sandboxEval(code: string) {\n    return func(code)();\n  }\n}\n\nexport function sandboxedSetTimeout(func: SandboxFunction): SandboxSetTimeout {\n  return function sandboxSetTimeout(handler, ...args) {\n    if (typeof handler !== 'string') return setTimeout(handler, ...args);\n    return setTimeout(func(handler), ...args);\n  };\n}\n\nexport function sandboxedSetInterval(func: SandboxFunction): SandboxSetInterval {\n  return function sandboxSetInterval(handler, ...args) {\n    if (typeof handler !== 'string') return setInterval(handler, ...args);\n    return setInterval(func(handler), ...args);\n  };\n}\n","import { createExecContext, IExecContext, IOptionParams, IScope } from './utils.js';\nimport { createEvalContext } from './eval.js';\nimport { ExecReturn } from './executor.js';\nimport parse from './parser.js';\nimport SandboxExec from './SandboxExec.js';\n\nexport default class Sandbox extends SandboxExec {\n  constructor(options?: IOptionParams) {\n    super(options, createEvalContext());\n  }\n\n  static audit<T>(code: string, scopes: IScope[] = []): ExecReturn<T> {\n    const globals: Record<string, unknown> = {};\n    for (const i of Object.getOwnPropertyNames(globalThis) as [keyof typeof globalThis]) {\n      globals[i] = globalThis[i];\n    }\n    const sandbox = new SandboxExec({\n      globals,\n      audit: true,\n    });\n    return sandbox.executeTree(\n      createExecContext(sandbox, parse(code, true), createEvalContext()),\n      scopes\n    );\n  }\n\n  static parse(code: string) {\n    return parse(code);\n  }\n\n  compile<T>(\n    code: string,\n    optimize = false\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => T } {\n    const parsed = parse(code, optimize);\n    const exec = (...scopes: IScope[]) => {\n      const context = createExecContext(this, parsed, this.evalContext);\n      return { context, run: () => this.executeTree<T>(context, [...scopes]).result };\n    };\n    return exec;\n  }\n\n  compileAsync<T>(\n    code: string,\n    optimize = false\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => Promise<T> } {\n    const parsed = parse(code, optimize);\n    const exec = (...scopes: IScope[]) => {\n      const context = createExecContext(this, parsed, this.evalContext);\n      return {\n        context,\n        run: () => this.executeTreeAsync<T>(context, [...scopes]).then((ret) => ret.result),\n      };\n    };\n    return exec;\n  }\n\n  compileExpression<T>(\n    code: string,\n    optimize = false\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => T } {\n    const parsed = parse(code, optimize, true);\n    const exec = (...scopes: IScope[]) => {\n      const context = createExecContext(this, parsed, this.evalContext);\n      return { context, run: () => this.executeTree<T>(context, [...scopes]).result };\n    };\n    return exec;\n  }\n\n  compileExpressionAsync<T>(\n    code: string,\n    optimize = false\n  ): (...scopes: IScope[]) => { context: IExecContext; run: () => Promise<T> } {\n    const parsed = parse(code, optimize, true);\n    const exec = (...scopes: IScope[]) => {\n      const context = createExecContext(this, parsed, this.evalContext);\n      return {\n        context,\n        run: () => this.executeTreeAsync<T>(context, [...scopes]).then((ret) => ret.result),\n      };\n    };\n    return exec;\n  }\n}\n"],"names":[],"mappings":";;;;;SAwBgB,iBAAiB,GAAA;IAC/B,OAAO;QACL,eAAe;QACf,aAAa;QACb,mBAAmB;QACnB,oBAAoB;QACpB,eAAe;KAChB,CAAC;AACJ,CAAC;AAEe,SAAA,eAAe,CAAC,OAAqB,EAAE,KAAa,EAAA;AAClE,IAAA,OAAO,eAAe,CAAC;IACvB,SAAS,eAAe,CAAC,GAAG,MAAgB,EAAA;QAC1C,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;AAChC,QAAA,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;AAC3B,QAAA,OAAO,cAAc,CACnB,MAAM,EACN,MAAM,CAAC,IAAI,EACX,KAAK,IAAI,YAAY,CAAC,OAAO,EAC7B;AACE,YAAA,GAAG,OAAO;YACV,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,IAAI,EAAE,MAAM,CAAC,IAAI;AAClB,SAAA,EACD,SAAS,EACT,WAAW,CACZ,CAAC;KACH;AACH,CAAC;AAEK,SAAU,aAAa,CAAC,IAAqB,EAAA;AACjD,IAAA,OAAO,WAAW,CAAC;IACnB,SAAS,WAAW,CAAC,IAAY,EAAA;AAC/B,QAAA,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;KACrB;AACH,CAAC;AAEK,SAAU,mBAAmB,CAAC,IAAqB,EAAA;AACvD,IAAA,OAAO,SAAS,iBAAiB,CAAC,OAAO,EAAE,GAAG,IAAI,EAAA;QAChD,IAAI,OAAO,OAAO,KAAK,QAAQ;AAAE,YAAA,OAAO,UAAU,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QACrE,OAAO,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;AAC5C,KAAC,CAAC;AACJ,CAAC;AAEK,SAAU,oBAAoB,CAAC,IAAqB,EAAA;AACxD,IAAA,OAAO,SAAS,kBAAkB,CAAC,OAAO,EAAE,GAAG,IAAI,EAAA;QACjD,IAAI,OAAO,OAAO,KAAK,QAAQ;AAAE,YAAA,OAAO,WAAW,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QACtE,OAAO,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;AAC7C,KAAC,CAAC;AACJ;;ACnEqB,MAAA,OAAQ,SAAQ,WAAW,CAAA;AAC9C,IAAA,WAAA,CAAY,OAAuB,EAAA;AACjC,QAAA,KAAK,CAAC,OAAO,EAAE,iBAAiB,EAAE,CAAC,CAAC;KACrC;AAED,IAAA,OAAO,KAAK,CAAI,IAAY,EAAE,SAAmB,EAAE,EAAA;QACjD,MAAM,OAAO,GAA4B,EAAE,CAAC;QAC5C,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,mBAAmB,CAAC,UAAU,CAA8B,EAAE;YACnF,OAAO,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;SAC5B;AACD,QAAA,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC;YAC9B,OAAO;AACP,YAAA,KAAK,EAAE,IAAI;AACZ,SAAA,CAAC,CAAC;QACH,OAAO,OAAO,CAAC,WAAW,CACxB,iBAAiB,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAClE,MAAM,CACP,CAAC;KACH;IAED,OAAO,KAAK,CAAC,IAAY,EAAA;AACvB,QAAA,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;KACpB;AAED,IAAA,OAAO,CACL,IAAY,EACZ,QAAQ,GAAG,KAAK,EAAA;QAEhB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACrC,QAAA,MAAM,IAAI,GAAG,CAAC,GAAG,MAAgB,KAAI;AACnC,YAAA,MAAM,OAAO,GAAG,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAClE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAC,WAAW,CAAI,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;AAClF,SAAC,CAAC;AACF,QAAA,OAAO,IAAI,CAAC;KACb;AAED,IAAA,YAAY,CACV,IAAY,EACZ,QAAQ,GAAG,KAAK,EAAA;QAEhB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACrC,QAAA,MAAM,IAAI,GAAG,CAAC,GAAG,MAAgB,KAAI;AACnC,YAAA,MAAM,OAAO,GAAG,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAClE,OAAO;gBACL,OAAO;gBACP,GAAG,EAAE,MAAM,IAAI,CAAC,gBAAgB,CAAI,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,MAAM,CAAC;aACpF,CAAC;AACJ,SAAC,CAAC;AACF,QAAA,OAAO,IAAI,CAAC;KACb;AAED,IAAA,iBAAiB,CACf,IAAY,EACZ,QAAQ,GAAG,KAAK,EAAA;QAEhB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC3C,QAAA,MAAM,IAAI,GAAG,CAAC,GAAG,MAAgB,KAAI;AACnC,YAAA,MAAM,OAAO,GAAG,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAClE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAC,WAAW,CAAI,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;AAClF,SAAC,CAAC;AACF,QAAA,OAAO,IAAI,CAAC;KACb;AAED,IAAA,sBAAsB,CACpB,IAAY,EACZ,QAAQ,GAAG,KAAK,EAAA;QAEhB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC3C,QAAA,MAAM,IAAI,GAAG,CAAC,GAAG,MAAgB,KAAI;AACnC,YAAA,MAAM,OAAO,GAAG,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAClE,OAAO;gBACL,OAAO;gBACP,GAAG,EAAE,MAAM,IAAI,CAAC,gBAAgB,CAAI,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,MAAM,CAAC;aACpF,CAAC;AACJ,SAAC,CAAC;AACF,QAAA,OAAO,IAAI,CAAC;KACb;AACF;;;;"}