simplex-lang 0.0.0

package/parser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/simplex.peggy"],"names":["$top_level_initializer","Start","SourceCharacter","WhiteSpace","LineTerminator","LineTerminatorSequence","Comment","MultiLineComment","MultiLineCommentNoLineTerminator","SingleLineComment","Identifier","IdentifierName","IdentifierStart","IdentifierPart","UnicodeLetter","UnicodeCombiningMark","ReservedWord","Keyword","Literal","NullLiteral","BooleanLiteral","NumericLiteral","DecimalLiteral","DecimalIntegerLiteral","DecimalDigit","NonZeroDigit","ExponentPart","ExponentIndicator","SignedInteger","HexIntegerLiteral","HexDigit","StringLiteral","DoubleStringCharacter","SingleStringCharacter","LineContinuation","EscapeSequence","CharacterEscapeSequence","SingleEscapeCharacter","NonEscapeCharacter","EscapeCharacter","HexEscapeSequence","UnicodeEscapeSequence","Ll","Lm","Lo","Lt","Lu","Mc","Mn","Nd","Nl","Pc","Zs","AndToken","ElseToken","FalseToken","IfToken","InToken","NotToken","NullToken","OrToken","ThenToken","TrueToken","TypeofToken","ModToken","__","_","EOS","EOF","PrimaryExpression","ArrayLiteral","ElementList","Elision","ObjectLiteral","PropertyNameAndValueList","PropertyAssignment","PropertyName","MemberExpression","CallExpression","Arguments","ArgumentList","LeftHandSideExpression","ExponentiationExpression","ExponentiationOperator","UnaryExpression","UnaryOperator","MultiplicativeExpression","MultiplicativeOperator","AdditiveExpression","AdditiveOperator","ConcatenationExpression","ConcatenationOperator","RelationalExpression","RelationalOperator","EqualityExpression","EqualityOperator","LogicalANDExpression","LogicalANDOperator","LogicalORExpression","LogicalOROperator","ConditionalExpression","NullishCoalescingExpression","NullishCoalescingOperator","PipeExpression","PipeOperator","ExpressionStatement"],"mappings":";;;;;AAAEA;AACFA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAIyC,mBAAmB,E;+BAsCrB,cAAc,E;qCAGN;AAC/C;AACA;AACA;AACA;AACA;AACA,IAAI,E;mCAMqC,kBAAkB,E;2BAmD5C;AACf;AACA;AACA;AACA;AACA;AACA,IAAI,E;2BAGW;AACf;AACA;AACA;AACA;AACA;AACA,IAAI,E;2BACY;AAChB;AACA;AACA;AACA;AACA;AACA,IAAI,E;kCAG6D;AACjE;AACA,IAAI,E;kCAC0D;AAC9D;AACA,IAAI,E;2BAGuD;AAC3D;AACA;AACA;AACA;AACA;AACA,IAAI,E;4BACiC;AACrC;AACA;AACA;AACA;AACA;AACA,IAAI,E;4BACqC;AACzC;AACA;AACA;AACA;AACA;AACA,IAAI,E;kCAsByB;AAC7B;AACA;AACA;AACA;AACA;AACA,IAAI,E;iCAMsC;AAC1C;AACA;AACA;AACA;AACA;AACA,IAAI,E;iCACsC;AAC1C;AACA;AACA;AACA;AACA;AACA,IAAI,E;4BAGgD,gBAAgB,E;oCAClC,kBAAkB,E;4BAIA,gBAAgB,E;oCAClC,kBAAkB,E;4BAInB,YAAY,E;4BAItB,cAAc,E;4BAY3B,cAAc,E;4BACd,cAAc,E;4BACd,cAAc,E;4BACd,cAAc,E;4BACd,cAAc,E;4BACd,cAAc,E;4BAGiC,gBAAgB,E;kCASpC;AACrC;AACA,IAAI,E;kCAGmD;AACvD;AACA,IAAI,E;sCAuEqC,oBAAoB,E;mCAGvB;AACtC;AACA;AACA;AACA;AACA;AACA,IAAI,E;oCACoC;AACxC;AACA;AACA;AACA;AACA;AACA,IAAI,E;6CACiE;AACrE;AACA;AACA;AACA;AACA;AACA,IAAI,E;4CAI4C;AAChD;AACA,MAAM,E;kDAGoD;AAC1D;AACA,MAAM,E;sCAED,kDAAkD,E;kCAG7B,8CAA8C,E;4BAGxD;AAChB;AACA;AACA;AACA;AACA;AACA,IAAI,E;sCACmD;AACvD;AACA;AACA;AACA;AACA;AACA,IAAI,E;sCAC0D;AAC9D;AACA;AACA;AACA;AACA;AACA,IAAI,E;sCAG8D;AAClE;AACA,IAAI,E;sCAG6C;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,E;0CAY0C;AAC9C;AACA;AACA;AACA,QAAQ,E;0CACmC;AAC3C;AACA;AACA;AACA,QAAQ,E;sCAEH;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,E;wCAI6C;AACjD;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,E;sCAGqB;AAC3B;AACA;AACA;AACA;AACA;AACA,QAAQ,E;0CACsC;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,E;0CACmC;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,E;sCAEH;AACL;AACA;AACA;AACA;AACA;AACA,IAAI,E;gCAGoC;AACxC;AACA,IAAI,E;sCAG8C;AAClD;AACA,IAAI,E;sCASC,uDAAuD,E;8CAOJ;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,E;sCAWC,uDAAuD,E;sCAUvD,uDAAuD,E;sCASvD,uDAAuD,E;sCAQvD,uDAAuD,E;sCAYvD,uDAAuD,E;sCASvD,wDAAwD,E;sCAQxD,wDAAwD,E;uDAUxD;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,E;4CAEuB;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,E;sCAMC;AACL;AACA;AACA;AACA;AACA,IAAI,E;sDASG,iCAAiC,E;sCAEnC;AACL;AACA;AACA;AACA,IAAI,E;sCAU4B;AAChC;AACA;AACA;AACA;AACA,IAAI,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA9oBJC,cAAK;;;;;;;;;;;;;;;;;;WAGLC,wBAAe;;;;;;;;;;;;;;WAGfC,mBAAU;;;;;;;;;;;;;;;;;;;;WASVC,uBAAc;;;;;;;;;;;;;;WAGdC,+BAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAOtBC,gBAAO;;;;;;;;;;;;;;;;;WAIPC,yBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGhBC,yCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGhCC,0BAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGjBC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGVC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;WASdC,wBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAMfC,uBAAc;;;;;;;;;;;;;;;;;WAQdC,sBAAa;;;;;;;;;;;;;;WAQbC,6BAAoB;;;;;;;;;;;;;;WAUpBC,qBAAY;;;;;;;;;;;;;;WAKZC,gBAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAWPC,gBAAO;;;;;;;;;;;;;;;;;WAMPC,oBAAW;;;;;;;;;;;;;;WASXC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;WAgBdC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAQdC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuBdC,8BAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIrBC,qBAAY;;;;;;;;;;;;;;WAGZC,qBAAY;;;;;;;;;;;;;;WAGZC,qBAAY;;;;;;;;;;;;;;;;;;;;;;WAGZC,0BAAiB;;;;;;;;;;;;;;WAGjBC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGbC,0BAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WASjBC,iBAAQ;;;;;;;;;;;;;;WAGRC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgBbC,8BAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKrBC,8BAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKrBC,yBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGhBC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAMdC,gCAAuB;;;;;;;;;;;WAIvBC,8BAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAWrBC,2BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGlBC,wBAAe;;;;;;;;;;;;;;;;;WAMfC,0BAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKjBC,8BAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAMrBC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAGFC,WAAE;;;;;;;;;;;;;;WAIFC,iBAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACRC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACTC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACVC,gBAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACPC,gBAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACPC,iBAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACRC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACTC,gBAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACPC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACTC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACTC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WACXC,iBAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGRC,WAAE;;;;;;;;;;;;;;;;;;;;;;;;;WAGFC,UAAC;;;;;;;;;;;;;;;;;;;WAGDC,YAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAMHC,YAAG;;;;;;;;;;;;;;;;;;;;;;;WAGHC,0BAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAOjBC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuBZC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAaXC,gBAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGPC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuBbC,iCAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKxBC,2BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAWlBC,qBAAY;;;;;;;;;;;;;;WAKZC,yBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4BhBC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4CdC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKTC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKZC,+BAAsB;;;;;;;;;;;WAItBC,iCAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKxBC,+BAAsB;;;;;;;;;;;;;;WAGtBC,wBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;WAYfC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAMbC,iCAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKxBC,+BAAsB;;;;;;;;;;;;;;;;;;;;;;;WAKtBC,2BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKlBC,yBAAgB;;;;;;;;;;;;;;WAIhBC,gCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKvBC,8BAAqB;;;;;;;;;;;;;;WAGrBC,6BAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKpBC,2BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAOlBC,2BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKlBC,yBAAgB;;;;;;;;;;;;;;;;;;;;;;;WAIhBC,6BAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKpBC,2BAAkB;;;;;;;;;;;;;;WAGlBC,4BAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKnBC,0BAAiB;;;;;;;;;;;;;;WAGjBC,8BAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BrBC,oCAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAU3BC,kCAAyB;;;;;;;;;;;;;;WAGzBC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAYdC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;WAOZC,4BAAmB","file":"index.js"}

package/parser/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@project/simplex-parser",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts"
+}

package/src/compiler.ts

@@ -0,0 +1,538 @@
+import { parse } from '@project/simplex-parser'
+import { ExpressionError, UnexpectedTypeError } from './errors.js'
+import {
+  BinaryExpression,
+  Expression,
+  ExpressionByType,
+  ExpressionStatement,
+  Location,
+  LogicalExpression,
+  UnaryExpression
+} from './simplex-tree.js'
+import {
+  bool,
+  ensureFunction,
+  isSimple,
+  num,
+  prettyType,
+  relComp,
+  toStr
+} from './utils.js'
+import assert from 'node:assert'
+
+interface ContextHelpers<Data, Globals> {
+  castToBoolean(this: void, val: unknown): boolean
+  ensureFunction(this: void, val: unknown): Function
+  getIdentifierValue(
+    this: void,
+    identifierName: string,
+    globals: Globals,
+    data: Data
+  ): unknown
+  getProperty(this: void, obj: unknown, key: unknown): unknown
+  callFunction(this: void, fn: unknown, args: unknown[] | null): unknown
+  pipe(
+    this: void,
+    head: unknown,
+    tail: { opt: boolean; next: (_: unknown) => unknown }[]
+  ): unknown
+}
+
+var hasOwn = Object.hasOwn
+var ERROR_STACK_REGEX = /<anonymous>:(?<row>\d+):(?<col>\d+)/g
+
+const defaultContextHelpers: ContextHelpers<
+  Record<string, unknown>,
+  Record<string, unknown>
+> = {
+  castToBoolean: bool,
+
+  ensureFunction,
+
+  getIdentifierValue: (identifierName, globals, data) => {
+    if (identifierName === 'undefined') return undefined
+
+    if (globals != null && Object.hasOwn(globals, identifierName)) {
+      return globals[identifierName]
+    }
+
+    if (data != null && Object.hasOwn(data, identifierName)) {
+      return data[identifierName]
+    }
+
+    throw new Error(`Unknown identifier - ${identifierName}`)
+  },
+
+  getProperty(obj, key) {
+    if (obj == null) return obj
+
+    if (typeof obj !== 'object') {
+      throw new UnexpectedTypeError('object', prettyType(obj))
+    }
+
+    if (isSimple(key) === false) {
+      throw new UnexpectedTypeError(
+        'object key to be simple type',
+        prettyType(key)
+      )
+    }
+
+    if (hasOwn(obj, key as any)) {
+      // @ts-expect-error Type cannot be used as an index type
+      return obj[key] as unknown
+    }
+
+    return undefined
+  },
+
+  callFunction(fn, args) {
+    return (
+      args === null
+        ? ensureFunction(fn)()
+        : ensureFunction(fn).apply(null, args)
+    ) as unknown
+  },
+
+  pipe(head, tail) {
+    var result = head
+    for (const it of tail) {
+      if (it.opt && result == null) return result
+      result = it.next(result)
+    }
+    return result
+  }
+}
+
+type ExpressionUnaryOperators = Record<
+  UnaryExpression['operator'],
+  (val: unknown) => unknown
+>
+
+export const defaultUnaryOperators: ExpressionUnaryOperators = {
+  '+': val => num(val),
+  '-': val => -num(val),
+  'not': val => !bool(val),
+  'typeof': val => typeof val
+}
+
+type ExpressionBinaryOperators = Record<
+  BinaryExpression['operator'] | LogicalExpression['operator'],
+  (left: unknown, right: unknown) => unknown
+>
+
+export const defaultBinaryOperators: ExpressionBinaryOperators = {
+  '!=': (a, b) => a !== b,
+
+  '==': (a, b) => a === b,
+
+  '*': (a, b) => num(a) * num(b),
+
+  '+': (a, b) => num(a) + num(b),
+
+  '&': (a, b) => toStr(a) + toStr(b),
+
+  '-': (a, b) => num(a) - num(b),
+
+  '/': (a, b) => num(a) / num(b),
+
+  'mod': (a, b) => {
+    return num(a) % num(b)
+  },
+
+  '<': (a, b) => relComp(a) < relComp(b),
+
+  '<=': (a, b) => relComp(a) <= relComp(b),
+
+  '>': (a, b) => relComp(a) > relComp(b),
+
+  '>=': (a, b) => relComp(a) >= relComp(b),
+
+  'in': (a, b) => {
+    if (isSimple(a) && b != null && typeof b === 'object') {
+      return Object.hasOwn(b, a as any)
+    } else {
+      throw new TypeError(
+        `Cannot use "in" operator to search for ${prettyType(a)} key in ${prettyType(b)}`
+      )
+    }
+  },
+
+  '^': (a, b) => num(a) ** num(b),
+
+  'and': (a, b) => bool(a) && bool(b),
+
+  'or': (a, b) => bool(a) || bool(b)
+}
+
+interface ExpressionOperators {
+  unaryOperators: Record<UnaryExpression['operator'], (val: unknown) => unknown>
+  binaryOperators: Record<
+    BinaryExpression['operator'] | LogicalExpression['operator'],
+    (left: unknown, right: unknown) => unknown
+  >
+}
+
+const PIPE_LTR = '_'
+
+export interface SourceLocation {
+  len: number
+  location: Location
+}
+
+export interface VisitResult {
+  code: string
+  offsets: SourceLocation[]
+}
+
+type Visit = (node: Expression) => VisitResult[]
+
+const codePart = (
+  codePart: string,
+  ownerNode: { location: Location }
+): VisitResult => ({
+  code: codePart,
+  offsets: [{ len: codePart.length, location: ownerNode.location }]
+})
+
+const combineVisitResults = (parts: VisitResult[]) => {
+  return parts.reduce((res, it) => {
+    return {
+      code: res.code + it.code,
+      offsets: res.offsets.concat(it.offsets)
+    } as VisitResult
+  })
+}
+
+const visitors: {
+  [P in keyof ExpressionByType]: (
+    node: ExpressionByType[P],
+    visit: Visit
+  ) => VisitResult[]
+} = {
+  Literal: node => {
+    const parts: VisitResult[] = [codePart(JSON.stringify(node.value), node)]
+
+    return parts
+  },
+
+  Identifier: node => {
+    if (node.name === PIPE_LTR) return [codePart(PIPE_LTR, node)]
+
+    const parts: VisitResult[] = [
+      codePart(`get(${JSON.stringify(node.name)})`, node)
+    ]
+
+    return parts
+  },
+
+  UnaryExpression: (node, visit) => {
+    const parts: VisitResult[] = [
+      codePart(`uop["${node.operator}"](`, node),
+      ...visit(node.argument),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  BinaryExpression: (node, visit) => {
+    const parts: VisitResult[] = [
+      codePart(`bop["${node.operator}"](`, node),
+      ...visit(node.left),
+      codePart(',', node),
+      ...visit(node.right),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  LogicalExpression: (node, visit) => {
+    const parts: VisitResult[] = [
+      codePart(`bop["${node.operator}"](`, node),
+      ...visit(node.left),
+      codePart(',', node),
+      ...visit(node.right),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  ConditionalExpression: (node, visit) => {
+    const parts: VisitResult[] = [
+      codePart('(bool(', node),
+      ...visit(node.test),
+      codePart(')?', node),
+      ...visit(node.consequent),
+      codePart(':', node),
+      ...(node.alternate !== null
+        ? visit(node.alternate)
+        : [codePart('undefined', node)]),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  ObjectExpression: (node, visit) => {
+    const innerObj = node.properties
+      .map((p): [VisitResult, VisitResult[]] => {
+        if (p.key.type === 'Identifier') {
+          return [codePart(p.key.name, p), visit(p.value)]
+        }
+        //
+        else if (p.key.type === 'Literal') {
+          // TODO look for ECMA spec
+          return [codePart(JSON.stringify(p.key.value), p), visit(p.value)]
+        }
+        //
+        else {
+          // TODO Restrict on parse step
+          // TODO Error with locations
+          throw new TypeError(`Incorrect object key type ${p.key.type}`)
+        }
+      })
+      .flatMap(([k, v]) => {
+        return [k, codePart(':', node), ...v, codePart(',', node)]
+      })
+
+    // remove last comma
+    if (innerObj.length > 1) {
+      innerObj.pop()
+    }
+
+    const parts: VisitResult[] = [
+      codePart('{', node),
+      ...innerObj,
+      codePart('}', node)
+    ]
+
+    return parts
+  },
+
+  ArrayExpression: (node, visit) => {
+    const innerArrParts = node.elements.flatMap(el => {
+      return el === null
+        ? [codePart(',', node)]
+        : [...visit(el), codePart(',', node)]
+    })
+
+    // remove last comma
+    if (innerArrParts.length > 1) {
+      innerArrParts.pop()
+    }
+
+    const parts: VisitResult[] = [
+      codePart('[', node),
+      ...innerArrParts,
+      codePart(']', node)
+    ]
+
+    return parts
+  },
+
+  MemberExpression: (node, visit) => {
+    const { computed, object, property } = node
+
+    // TODO Pass computed to prop?
+
+    const parts: VisitResult[] = [
+      codePart('prop(', node),
+      ...visit(object),
+      codePart(',', node),
+      ...(computed
+        ? visit(property)
+        : [codePart(JSON.stringify(property.name), property)]),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  CallExpression: (node, visit) => {
+    const innerArgs =
+      node.arguments.length > 0
+        ? node.arguments.flatMap(arg => [...visit(arg), codePart(',', node)])
+        : null
+
+    // remove last comma
+    innerArgs?.pop()
+
+    const parts: VisitResult[] = [
+      codePart('call(', node),
+      ...visit(node.callee),
+      codePart(',', node),
+      ...(innerArgs === null
+        ? [codePart('null', node)]
+        : [codePart('[', node), ...innerArgs, codePart(']', node)]),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  NullishCoalescingExpression: (node, visit) => {
+    const parts: VisitResult[] = [
+      codePart('(', node),
+      ...visit(node.left),
+      codePart('??', node),
+      ...visit(node.right),
+      codePart(')', node)
+    ]
+
+    return parts
+  },
+
+  PipeSequence: (node, visit) => {
+    const headCode = visit(node.head)
+
+    const tailsCodeArrInner = node.tail.flatMap(t => {
+      const opt = t.operator === '|?'
+
+      const tailParts: VisitResult[] = [
+        codePart(
+          `{opt:${opt},next:function(${PIPE_LTR}){return `,
+          t.expression
+        ),
+        ...visit(t.expression),
+        codePart(`}}`, t.expression),
+        codePart(`,`, t.expression)
+      ]
+
+      return tailParts
+    })
+
+    // remove last comma
+    tailsCodeArrInner.pop()
+
+    const parts: VisitResult[] = [
+      codePart('pipe(', node),
+      ...headCode,
+      codePart(',[', node),
+      ...tailsCodeArrInner,
+      codePart('])', node)
+    ]
+
+    return parts
+  }
+}
+
+const visit: (
+  node: Expression,
+  parentNode: Expression | null
+) => VisitResult[] = node => {
+  const nodeTypeVisitor = visitors[node.type]
+
+  if (nodeTypeVisitor === undefined) {
+    throw new Error(`No handler for node type - ${node.type}`)
+  }
+
+  const innerVisit: Visit = (childNode: Expression) => {
+    return visit(childNode, node)
+  }
+
+  // @ts-expect-error skip node is never
+  return nodeTypeVisitor(node, innerVisit)
+}
+
+export function traverse(tree: ExpressionStatement): VisitResult {
+  return combineVisitResults(visit(tree.expression, null))
+}
+
+function getExpressionErrorLocation(
+  colOffset: number,
+  locations: SourceLocation[]
+): Location | null {
+  var curCol = 0
+  for (const loc of locations) {
+    curCol += loc.len
+    if (curCol >= colOffset) return loc.location
+  }
+  return null
+}
+
+export type CompileOptions<Data, Globals> = Partial<
+  ContextHelpers<Data, Globals> & ExpressionOperators & { globals: Globals }
+>
+
+export function compile<Data = Record<string, unknown>, Globals = null>(
+  expression: string,
+  options?: CompileOptions<Data, Globals>
+): (data?: Data) => unknown {
+  const tree = parse(expression) as ExpressionStatement
+  const traverseResult = traverse(tree)
+
+  const { code: expressionCode, offsets } = traverseResult
+
+  const bootstrapCodeHead = [
+    `var bool = ctx.castToBoolean;`,
+    `var bop = ctx.binaryOperators;`,
+    `var uop = ctx.unaryOperators;`,
+    `var call = ctx.callFunction;`,
+    `var getIdentifierValue = ctx.getIdentifierValue;`,
+    `var prop = ctx.getProperty;`,
+    `var pipe = ctx.pipe;`,
+    `var globals = ctx.globals ?? null;`,
+    `return data => {`,
+    `var get = name => getIdentifierValue(name, globals, data);`,
+    `return `
+  ].join('')
+
+  const bootstrapCodeHeadLen = bootstrapCodeHead.length
+
+  const functionCode = bootstrapCodeHead + expressionCode + ';}'
+
+  const func = new Function('ctx', functionCode)({
+    ...defaultContextHelpers,
+    ...{
+      unaryOperators: defaultUnaryOperators,
+      binaryOperators: defaultBinaryOperators
+    },
+    ...options
+  }) as (data?: Data) => unknown
+
+  return function (data?: Data) {
+    try {
+      return func(data)
+    } catch (err) {
+      assert.ok(err instanceof Error)
+
+      const stackRows = err.stack?.split('\n').map(row => row.trim())
+
+      const evalRow = stackRows?.find(row => row.startsWith('at eval '))
+
+      if (evalRow === undefined) {
+        throw err
+      }
+
+      ERROR_STACK_REGEX.lastIndex = 0
+      const match = ERROR_STACK_REGEX.exec(evalRow)
+
+      if (match == null) {
+        throw err
+      }
+
+      const rowOffsetStr = match.groups?.['row']
+      const colOffsetStr = match.groups?.['col']
+
+      if (rowOffsetStr === undefined || colOffsetStr === undefined) {
+        throw err
+      }
+
+      const rowOffset = Number.parseInt(rowOffsetStr)
+      assert.equal(rowOffset, 3)
+
+      const colOffset = Number.parseInt(colOffsetStr)
+      const adjustedColOffset = colOffset - bootstrapCodeHeadLen
+      assert.ok(adjustedColOffset >= 0)
+
+      const errorLocation = getExpressionErrorLocation(
+        adjustedColOffset,
+        offsets
+      )
+
+      throw new ExpressionError(err, errorLocation)
+    }
+  }
+}

package/src/errors.ts

@@ -0,0 +1,21 @@
+import { Location } from './simplex-tree.js'
+
+export class ExpressionError extends Error {
+  constructor(
+    error: Error,
+    public location: Location | null
+  ) {
+    super(error.message, { cause: error })
+  }
+}
+
+export class UnexpectedTypeError extends TypeError {
+  I18N_STRING = 'UNEXPECTED_TYPE'
+
+  constructor(
+    public expectedType: string,
+    public receivedType: string
+  ) {
+    super(`Expected ${expectedType}, but got ${receivedType} instead.`)
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './compiler.js'
+export * from './errors.js'
+export * from './simplex-tree.js'