@mapwhit/tilerenderer 0.50.0 → 0.51.0

package/src/style-spec/expression/definitions/index.js

@@ -1,339 +0,0 @@
-const {
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  ObjectType,
-  ValueType,
-  ErrorType,
-  CollatorType,
-  array,
-  toString: typeToString
-} = require('../types');
-
-const { typeOf, Color, validateRGBA, toString: valueToString } = require('../values');
-const CompoundExpression = require('../compound_expression');
-const RuntimeError = require('../runtime_error');
-const Let = require('./let');
-const Var = require('./var');
-const Literal = require('./literal');
-const Assertion = require('./assertion');
-const Coercion = require('./coercion');
-const At = require('./at');
-const Match = require('./match');
-const Case = require('./case');
-const Step = require('./step');
-const Interpolate = require('./interpolate');
-const Coalesce = require('./coalesce');
-const { Equals, NotEquals, LessThan, GreaterThan, LessThanOrEqual, GreaterThanOrEqual } = require('./comparison');
-const { CollatorExpression } = require('./collator');
-const { FormatExpression } = require('./format');
-const Length = require('./length');
-
-const expressions = {
-  // special forms
-  '==': Equals,
-  '!=': NotEquals,
-  '>': GreaterThan,
-  '<': LessThan,
-  '>=': GreaterThanOrEqual,
-  '<=': LessThanOrEqual,
-  array: Assertion,
-  at: At,
-  boolean: Assertion,
-  case: Case,
-  coalesce: Coalesce,
-  collator: CollatorExpression,
-  format: FormatExpression,
-  interpolate: Interpolate,
-  'interpolate-hcl': Interpolate,
-  'interpolate-lab': Interpolate,
-  length: Length,
-  let: Let,
-  literal: Literal,
-  match: Match,
-  number: Assertion,
-  object: Assertion,
-  step: Step,
-  string: Assertion,
-  'to-boolean': Coercion,
-  'to-color': Coercion,
-  'to-number': Coercion,
-  'to-string': Coercion,
-  var: Var
-};
-
-function rgba(ctx, [r, g, b, a]) {
-  r = r.evaluate(ctx);
-  g = g.evaluate(ctx);
-  b = b.evaluate(ctx);
-  const alpha = a ? a.evaluate(ctx) : 1;
-  const error = validateRGBA(r, g, b, alpha);
-  if (error) throw new RuntimeError(error);
-  return new Color((r / 255) * alpha, (g / 255) * alpha, (b / 255) * alpha, alpha);
-}
-
-function has(key, obj) {
-  return key in obj;
-}
-
-function get(key, obj) {
-  const v = obj[key];
-  return typeof v === 'undefined' ? null : v;
-}
-
-function binarySearch(v, a, i, j) {
-  while (i <= j) {
-    const m = (i + j) >> 1;
-    if (a[m] === v) return true;
-    if (a[m] > v) j = m - 1;
-    else i = m + 1;
-  }
-  return false;
-}
-
-function varargs(type) {
-  return { type };
-}
-
-CompoundExpression.register(expressions, {
-  error: [
-    ErrorType,
-    [StringType],
-    (ctx, [v]) => {
-      throw new RuntimeError(v.evaluate(ctx));
-    }
-  ],
-  typeof: [StringType, [ValueType], (ctx, [v]) => typeToString(typeOf(v.evaluate(ctx)))],
-  'to-rgba': [
-    array(NumberType, 4),
-    [ColorType],
-    (ctx, [v]) => {
-      return v.evaluate(ctx).toArray();
-    }
-  ],
-  rgb: [ColorType, [NumberType, NumberType, NumberType], rgba],
-  rgba: [ColorType, [NumberType, NumberType, NumberType, NumberType], rgba],
-  has: {
-    type: BooleanType,
-    overloads: [
-      [[StringType], (ctx, [key]) => has(key.evaluate(ctx), ctx.properties())],
-      [[StringType, ObjectType], (ctx, [key, obj]) => has(key.evaluate(ctx), obj.evaluate(ctx))]
-    ]
-  },
-  get: {
-    type: ValueType,
-    overloads: [
-      [[StringType], (ctx, [key]) => get(key.evaluate(ctx), ctx.properties())],
-      [[StringType, ObjectType], (ctx, [key, obj]) => get(key.evaluate(ctx), obj.evaluate(ctx))]
-    ]
-  },
-  'feature-state': [ValueType, [StringType], (ctx, [key]) => get(key.evaluate(ctx), ctx.featureState || {})],
-  properties: [ObjectType, [], ctx => ctx.properties()],
-  'geometry-type': [StringType, [], ctx => ctx.geometryType()],
-  id: [ValueType, [], ctx => ctx.id()],
-  zoom: [NumberType, [], ctx => ctx.globals.zoom],
-  'heatmap-density': [NumberType, [], ctx => ctx.globals.heatmapDensity || 0],
-  'line-progress': [NumberType, [], ctx => ctx.globals.lineProgress || 0],
-  '+': [
-    NumberType,
-    varargs(NumberType),
-    (ctx, args) => {
-      let result = 0;
-      for (const arg of args) {
-        result += arg.evaluate(ctx);
-      }
-      return result;
-    }
-  ],
-  '*': [
-    NumberType,
-    varargs(NumberType),
-    (ctx, args) => {
-      let result = 1;
-      for (const arg of args) {
-        result *= arg.evaluate(ctx);
-      }
-      return result;
-    }
-  ],
-  '-': {
-    type: NumberType,
-    overloads: [
-      [[NumberType, NumberType], (ctx, [a, b]) => a.evaluate(ctx) - b.evaluate(ctx)],
-      [[NumberType], (ctx, [a]) => -a.evaluate(ctx)]
-    ]
-  },
-  '/': [NumberType, [NumberType, NumberType], (ctx, [a, b]) => a.evaluate(ctx) / b.evaluate(ctx)],
-  '%': [NumberType, [NumberType, NumberType], (ctx, [a, b]) => a.evaluate(ctx) % b.evaluate(ctx)],
-  ln2: [NumberType, [], () => Math.LN2],
-  pi: [NumberType, [], () => Math.PI],
-  e: [NumberType, [], () => Math.E],
-  '^': [NumberType, [NumberType, NumberType], (ctx, [b, e]) => b.evaluate(ctx) ** e.evaluate(ctx)],
-  sqrt: [NumberType, [NumberType], (ctx, [x]) => Math.sqrt(x.evaluate(ctx))],
-  log10: [NumberType, [NumberType], (ctx, [n]) => Math.log10(n.evaluate(ctx))],
-  ln: [NumberType, [NumberType], (ctx, [n]) => Math.log(n.evaluate(ctx))],
-  log2: [NumberType, [NumberType], (ctx, [n]) => Math.log2(n.evaluate(ctx))],
-  sin: [NumberType, [NumberType], (ctx, [n]) => Math.sin(n.evaluate(ctx))],
-  cos: [NumberType, [NumberType], (ctx, [n]) => Math.cos(n.evaluate(ctx))],
-  tan: [NumberType, [NumberType], (ctx, [n]) => Math.tan(n.evaluate(ctx))],
-  asin: [NumberType, [NumberType], (ctx, [n]) => Math.asin(n.evaluate(ctx))],
-  acos: [NumberType, [NumberType], (ctx, [n]) => Math.acos(n.evaluate(ctx))],
-  atan: [NumberType, [NumberType], (ctx, [n]) => Math.atan(n.evaluate(ctx))],
-  min: [NumberType, varargs(NumberType), (ctx, args) => Math.min(...args.map(arg => arg.evaluate(ctx)))],
-  max: [NumberType, varargs(NumberType), (ctx, args) => Math.max(...args.map(arg => arg.evaluate(ctx)))],
-  abs: [NumberType, [NumberType], (ctx, [n]) => Math.abs(n.evaluate(ctx))],
-  round: [
-    NumberType,
-    [NumberType],
-    (ctx, [n]) => {
-      const v = n.evaluate(ctx);
-      // Javascript's Math.round() rounds towards +Infinity for halfway
-      // values, even when they're negative. It's more common to round
-      // away from 0 (e.g., this is what python and C++ do)
-      return v < 0 ? -Math.round(-v) : Math.round(v);
-    }
-  ],
-  floor: [NumberType, [NumberType], (ctx, [n]) => Math.floor(n.evaluate(ctx))],
-  ceil: [NumberType, [NumberType], (ctx, [n]) => Math.ceil(n.evaluate(ctx))],
-  'filter-==': [BooleanType, [StringType, ValueType], (ctx, [k, v]) => ctx.properties()[k.value] === v.value],
-  'filter-id-==': [BooleanType, [ValueType], (ctx, [v]) => ctx.id() === v.value],
-  'filter-type-==': [BooleanType, [StringType], (ctx, [v]) => ctx.geometryType() === v.value],
-  'filter-<': [
-    BooleanType,
-    [StringType, ValueType],
-    (ctx, [k, v]) => {
-      const a = ctx.properties()[k.value];
-      const b = v.value;
-      return typeof a === typeof b && a < b;
-    }
-  ],
-  'filter-id-<': [
-    BooleanType,
-    [ValueType],
-    (ctx, [v]) => {
-      const a = ctx.id();
-      const b = v.value;
-      return typeof a === typeof b && a < b;
-    }
-  ],
-  'filter->': [
-    BooleanType,
-    [StringType, ValueType],
-    (ctx, [k, v]) => {
-      const a = ctx.properties()[k.value];
-      const b = v.value;
-      return typeof a === typeof b && a > b;
-    }
-  ],
-  'filter-id->': [
-    BooleanType,
-    [ValueType],
-    (ctx, [v]) => {
-      const a = ctx.id();
-      const b = v.value;
-      return typeof a === typeof b && a > b;
-    }
-  ],
-  'filter-<=': [
-    BooleanType,
-    [StringType, ValueType],
-    (ctx, [k, v]) => {
-      const a = ctx.properties()[k.value];
-      const b = v.value;
-      return typeof a === typeof b && a <= b;
-    }
-  ],
-  'filter-id-<=': [
-    BooleanType,
-    [ValueType],
-    (ctx, [v]) => {
-      const a = ctx.id();
-      const b = v.value;
-      return typeof a === typeof b && a <= b;
-    }
-  ],
-  'filter->=': [
-    BooleanType,
-    [StringType, ValueType],
-    (ctx, [k, v]) => {
-      const a = ctx.properties()[k.value];
-      const b = v.value;
-      return typeof a === typeof b && a >= b;
-    }
-  ],
-  'filter-id->=': [
-    BooleanType,
-    [ValueType],
-    (ctx, [v]) => {
-      const a = ctx.id();
-      const b = v.value;
-      return typeof a === typeof b && a >= b;
-    }
-  ],
-  'filter-has': [BooleanType, [ValueType], (ctx, [k]) => k.value in ctx.properties()],
-  'filter-has-id': [BooleanType, [], ctx => ctx.id() !== null],
-  'filter-type-in': [BooleanType, [array(StringType)], (ctx, [v]) => v.value.indexOf(ctx.geometryType()) >= 0],
-  'filter-id-in': [BooleanType, [array(ValueType)], (ctx, [v]) => v.value.indexOf(ctx.id()) >= 0],
-  'filter-in-small': [
-    BooleanType,
-    [StringType, array(ValueType)],
-    // assumes v is an array literal
-    (ctx, [k, v]) => v.value.indexOf(ctx.properties()[k.value]) >= 0
-  ],
-  'filter-in-large': [
-    BooleanType,
-    [StringType, array(ValueType)],
-    // assumes v is a array literal with values sorted in ascending order and of a single type
-    (ctx, [k, v]) => binarySearch(ctx.properties()[k.value], v.value, 0, v.value.length - 1)
-  ],
-  all: {
-    type: BooleanType,
-    overloads: [
-      [[BooleanType, BooleanType], (ctx, [a, b]) => a.evaluate(ctx) && b.evaluate(ctx)],
-      [
-        varargs(BooleanType),
-        (ctx, args) => {
-          for (const arg of args) {
-            if (!arg.evaluate(ctx)) return false;
-          }
-          return true;
-        }
-      ]
-    ]
-  },
-  any: {
-    type: BooleanType,
-    overloads: [
-      [[BooleanType, BooleanType], (ctx, [a, b]) => a.evaluate(ctx) || b.evaluate(ctx)],
-      [
-        varargs(BooleanType),
-        (ctx, args) => {
-          for (const arg of args) {
-            if (arg.evaluate(ctx)) return true;
-          }
-          return false;
-        }
-      ]
-    ]
-  },
-  '!': [BooleanType, [BooleanType], (ctx, [b]) => !b.evaluate(ctx)],
-  'is-supported-script': [
-    BooleanType,
-    [StringType],
-    // At parse time this will always return true, so we need to exclude this expression with isGlobalPropertyConstant
-    (ctx, [s]) => {
-      const isSupportedScript = ctx.globals?.isSupportedScript;
-      if (isSupportedScript) {
-        return isSupportedScript(s.evaluate(ctx));
-      }
-      return true;
-    }
-  ],
-  upcase: [StringType, [StringType], (ctx, [s]) => s.evaluate(ctx).toUpperCase()],
-  downcase: [StringType, [StringType], (ctx, [s]) => s.evaluate(ctx).toLowerCase()],
-  concat: [StringType, varargs(ValueType), (ctx, args) => args.map(arg => valueToString(arg.evaluate(ctx))).join('')],
-  'resolved-locale': [StringType, [CollatorType], (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()]
-});
-
-module.exports = expressions;

package/src/style-spec/expression/definitions/interpolate.js

@@ -1,245 +0,0 @@
-const UnitBezier = require('@mapbox/unitbezier');
-
-const interpolate = require('../../util/interpolate');
-const { toString, ColorType, NumberType } = require('../types');
-const { findStopLessThanOrEqualTo } = require('../stops');
-const { hcl, lab } = require('../../util/color_spaces');
-
-class Interpolate {
-  constructor(type, operator, interpolation, input, stops) {
-    this.type = type;
-    this.operator = operator;
-    this.interpolation = interpolation;
-    this.input = input;
-
-    this.labels = [];
-    this.outputs = [];
-    for (const [label, expression] of stops) {
-      this.labels.push(label);
-      this.outputs.push(expression);
-    }
-  }
-
-  static interpolationFactor(interpolation, input, lower, upper) {
-    let t = 0;
-    if (interpolation.name === 'exponential') {
-      t = exponentialInterpolation(input, interpolation.base, lower, upper);
-    } else if (interpolation.name === 'linear') {
-      t = exponentialInterpolation(input, 1, lower, upper);
-    } else if (interpolation.name === 'cubic-bezier') {
-      const c = interpolation.controlPoints;
-      const ub = new UnitBezier(c[0], c[1], c[2], c[3]);
-      t = ub.solve(exponentialInterpolation(input, 1, lower, upper));
-    }
-    return t;
-  }
-
-  static parse(args, context) {
-    let [operator, interpolation, input, ...rest] = args;
-
-    if (!Array.isArray(interpolation) || interpolation.length === 0) {
-      return context.error('Expected an interpolation type expression.', 1);
-    }
-
-    if (interpolation[0] === 'linear') {
-      interpolation = { name: 'linear' };
-    } else if (interpolation[0] === 'exponential') {
-      const base = interpolation[1];
-      if (typeof base !== 'number') return context.error('Exponential interpolation requires a numeric base.', 1, 1);
-      interpolation = {
-        name: 'exponential',
-        base
-      };
-    } else if (interpolation[0] === 'cubic-bezier') {
-      const controlPoints = interpolation.slice(1);
-      if (controlPoints.length !== 4 || controlPoints.some(t => typeof t !== 'number' || t < 0 || t > 1)) {
-        return context.error(
-          'Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.',
-          1
-        );
-      }
-
-      interpolation = {
-        name: 'cubic-bezier',
-        controlPoints: controlPoints
-      };
-    } else {
-      return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
-    }
-
-    if (args.length - 1 < 4) {
-      return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-    }
-
-    if ((args.length - 1) % 2 !== 0) {
-      return context.error('Expected an even number of arguments.');
-    }
-
-    input = context.parse(input, 2, NumberType);
-    if (!input) return null;
-
-    const stops = [];
-
-    let outputType = null;
-    if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
-      outputType = ColorType;
-    } else if (context.expectedType && context.expectedType.kind !== 'value') {
-      outputType = context.expectedType;
-    }
-
-    for (let i = 0; i < rest.length; i += 2) {
-      const label = rest[i];
-      const value = rest[i + 1];
-
-      const labelKey = i + 3;
-      const valueKey = i + 4;
-
-      if (typeof label !== 'number') {
-        return context.error(
-          'Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.',
-          labelKey
-        );
-      }
-
-      if (stops.length && stops[stops.length - 1][0] >= label) {
-        return context.error(
-          'Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.',
-          labelKey
-        );
-      }
-
-      const parsed = context.parse(value, valueKey, outputType);
-      if (!parsed) return null;
-      outputType = outputType || parsed.type;
-      stops.push([label, parsed]);
-    }
-
-    if (
-      outputType.kind !== 'number' &&
-      outputType.kind !== 'color' &&
-      !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')
-    ) {
-      return context.error(`Type ${toString(outputType)} is not interpolatable.`);
-    }
-
-    return new Interpolate(outputType, operator, interpolation, input, stops);
-  }
-
-  evaluate(ctx) {
-    const labels = this.labels;
-    const outputs = this.outputs;
-
-    if (labels.length === 1) {
-      return outputs[0].evaluate(ctx);
-    }
-
-    const value = this.input.evaluate(ctx);
-    if (value <= labels[0]) {
-      return outputs[0].evaluate(ctx);
-    }
-
-    const stopCount = labels.length;
-    if (value >= labels[stopCount - 1]) {
-      return outputs[stopCount - 1].evaluate(ctx);
-    }
-
-    const index = findStopLessThanOrEqualTo(labels, value);
-    const lower = labels[index];
-    const upper = labels[index + 1];
-    const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
-
-    const outputLower = outputs[index].evaluate(ctx);
-    const outputUpper = outputs[index + 1].evaluate(ctx);
-
-    if (this.operator === 'interpolate') {
-      return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
-    }
-    if (this.operator === 'interpolate-hcl') {
-      return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
-    }
-    return lab.reverse(lab.interpolate(lab.forward(outputLower), lab.forward(outputUpper), t));
-  }
-
-  eachChild(fn) {
-    fn(this.input);
-    for (const expression of this.outputs) {
-      fn(expression);
-    }
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.outputs.map(output => output.possibleOutputs()));
-  }
-
-  serialize() {
-    let interpolation;
-    if (this.interpolation.name === 'linear') {
-      interpolation = ['linear'];
-    } else if (this.interpolation.name === 'exponential') {
-      if (this.interpolation.base === 1) {
-        interpolation = ['linear'];
-      } else {
-        interpolation = ['exponential', this.interpolation.base];
-      }
-    } else {
-      interpolation = ['cubic-bezier'].concat(this.interpolation.controlPoints);
-    }
-
-    const serialized = [this.operator, interpolation, this.input.serialize()];
-
-    for (let i = 0; i < this.labels.length; i++) {
-      serialized.push(this.labels[i], this.outputs[i].serialize());
-    }
-    return serialized;
-  }
-}
-
-/**
- * Returns a ratio that can be used to interpolate between exponential function
- * stops.
- * How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
- * and `a` and `b` are constants affording sufficient degrees of freedom to fit
- * the function to the given stops.
- *
- * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
- * values without explicitly solving for `a` and `b`:
- *
- * First stop value: `f(x0) = y0 = a * base^x0 + b`
- * Second stop value: `f(x1) = y1 = a * base^x1 + b`
- * => `y1 - y0 = a(base^x1 - base^x0)`
- * => `a = (y1 - y0)/(base^x1 - base^x0)`
- *
- * Desired value: `f(x) = y = a * base^x + b`
- * => `f(x) = y0 + a * (base^x - base^x0)`
- *
- * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
- * little algebra:
- * ```
- * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
- *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
- * ```
- *
- * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
- * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
- * an interpolation factor between the two stops' output values.
- *
- * (Note: a slightly different form for `ratio`,
- * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
- * expensive `Math.pow()` operations.)
- *
- * @private
- */
-function exponentialInterpolation(input, base, lowerValue, upperValue) {
-  const difference = upperValue - lowerValue;
-  const progress = input - lowerValue;
-
-  if (difference === 0) {
-    return 0;
-  }
-  if (base === 1) {
-    return progress / difference;
-  }
-  return (base ** progress - 1) / (base ** difference - 1);
-}
-
-module.exports = Interpolate;

package/src/style-spec/expression/definitions/length.js

@@ -1,54 +0,0 @@
-const { NumberType, toString } = require('../types');
-
-const { typeOf } = require('../values');
-const RuntimeError = require('../runtime_error');
-
-class Length {
-  constructor(input) {
-    this.type = NumberType;
-    this.input = input;
-  }
-
-  static parse(args, context) {
-    if (args.length !== 2) return context.error(`Expected 1 argument, but found ${args.length - 1} instead.`);
-
-    const input = context.parse(args[1], 1);
-    if (!input) return null;
-
-    if (input.type.kind !== 'array' && input.type.kind !== 'string' && input.type.kind !== 'value')
-      return context.error(`Expected argument of type string or array, but found ${toString(input.type)} instead.`);
-
-    return new Length(input);
-  }
-
-  evaluate(ctx) {
-    const input = this.input.evaluate(ctx);
-    if (typeof input === 'string') {
-      return input.length;
-    }
-    if (Array.isArray(input)) {
-      return input.length;
-    }
-    throw new RuntimeError(
-      `Expected value to be of type string or array, but found ${toString(typeOf(input))} instead.`
-    );
-  }
-
-  eachChild(fn) {
-    fn(this.input);
-  }
-
-  possibleOutputs() {
-    return [undefined];
-  }
-
-  serialize() {
-    const serialized = ['length'];
-    this.eachChild(child => {
-      serialized.push(child.serialize());
-    });
-    return serialized;
-  }
-}
-
-module.exports = Length;

package/src/style-spec/expression/definitions/let.js

@@ -1,60 +0,0 @@
-class Let {
-  constructor(bindings, result) {
-    this.type = result.type;
-    this.bindings = [].concat(bindings);
-    this.result = result;
-  }
-
-  evaluate(ctx) {
-    return this.result.evaluate(ctx);
-  }
-
-  eachChild(fn) {
-    for (const binding of this.bindings) {
-      fn(binding[1]);
-    }
-    fn(this.result);
-  }
-
-  static parse(args, context) {
-    if (args.length < 4) return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
-
-    const bindings = [];
-    for (let i = 1; i < args.length - 1; i += 2) {
-      const name = args[i];
-
-      if (typeof name !== 'string') {
-        return context.error(`Expected string, but found ${typeof name} instead.`, i);
-      }
-
-      if (/[^a-zA-Z0-9_]/.test(name)) {
-        return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
-      }
-
-      const value = context.parse(args[i + 1], i + 1);
-      if (!value) return null;
-
-      bindings.push([name, value]);
-    }
-
-    const result = context.parse(args[args.length - 1], args.length - 1, context.expectedType, bindings);
-    if (!result) return null;
-
-    return new Let(bindings, result);
-  }
-
-  possibleOutputs() {
-    return this.result.possibleOutputs();
-  }
-
-  serialize() {
-    const serialized = ['let'];
-    for (const [name, expr] of this.bindings) {
-      serialized.push(name, expr.serialize());
-    }
-    serialized.push(this.result.serialize());
-    return serialized;
-  }
-}
-
-module.exports = Let;