@mapwhit/tilerenderer 0.47.1

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

@@ -0,0 +1,407 @@
+const {
+  NumberType,
+  StringType,
+  BooleanType,
+  ColorType,
+  ObjectType,
+  ValueType,
+  ErrorType,
+  CollatorType,
+  array,
+  toString
+} = require('../types');
+
+const { typeOf, Color, validateRGBA } = 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 ArrayAssertion = require('./array');
+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 } = require('./equals');
+const { CollatorExpression } = require('./collator');
+const Length = require('./length');
+
+const expressions = {
+  // special forms
+  '==': Equals,
+  '!=': NotEquals,
+  array: ArrayAssertion,
+  at: At,
+  boolean: Assertion,
+  case: Case,
+  coalesce: Coalesce,
+  collator: CollatorExpression,
+  interpolate: Interpolate,
+  length: Length,
+  let: Let,
+  literal: Literal,
+  match: Match,
+  number: Assertion,
+  object: Assertion,
+  step: Step,
+  string: Assertion,
+  'to-color': Coercion,
+  'to-number': 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 lt(ctx, [a, b]) {
+  return a.evaluate(ctx) < b.evaluate(ctx);
+}
+function gt(ctx, [a, b]) {
+  return a.evaluate(ctx) > b.evaluate(ctx);
+}
+function lteq(ctx, [a, b]) {
+  return a.evaluate(ctx) <= b.evaluate(ctx);
+}
+function gteq(ctx, [a, b]) {
+  return a.evaluate(ctx) >= b.evaluate(ctx);
+}
+
+function ltCollate(ctx, [a, b, c]) {
+  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) < 0;
+}
+function gtCollate(ctx, [a, b, c]) {
+  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) > 0;
+}
+function lteqCollate(ctx, [a, b, c]) {
+  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) <= 0;
+}
+function gteqCollate(ctx, [a, b, c]) {
+  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) >= 0;
+}
+
+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]) => toString(typeOf(v.evaluate(ctx)))],
+  'to-string': [
+    StringType,
+    [ValueType],
+    (ctx, [v]) => {
+      v = v.evaluate(ctx);
+      const type = typeof v;
+      if (v === null) {
+        return '';
+      }
+      if (type === 'string' || type === 'number' || type === 'boolean') {
+        return String(v);
+      }
+      if (v instanceof Color) {
+        return v.toString();
+      }
+      return JSON.stringify(v);
+    }
+  ],
+  'to-boolean': [BooleanType, [ValueType], (ctx, [v]) => Boolean(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)
+  ],
+  '>': {
+    type: BooleanType,
+    overloads: [
+      [[NumberType, NumberType], gt],
+      [[StringType, StringType], gt],
+      [[StringType, StringType, CollatorType], gtCollate]
+    ]
+  },
+  '<': {
+    type: BooleanType,
+    overloads: [
+      [[NumberType, NumberType], lt],
+      [[StringType, StringType], lt],
+      [[StringType, StringType, CollatorType], ltCollate]
+    ]
+  },
+  '>=': {
+    type: BooleanType,
+    overloads: [
+      [[NumberType, NumberType], gteq],
+      [[StringType, StringType], gteq],
+      [[StringType, StringType, CollatorType], gteqCollate]
+    ]
+  },
+  '<=': {
+    type: BooleanType,
+    overloads: [
+      [[NumberType, NumberType], lteq],
+      [[StringType, StringType], lteq],
+      [[StringType, StringType, CollatorType], lteqCollate]
+    ]
+  },
+  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(StringType), (ctx, args) => args.map(arg => 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

@@ -0,0 +1,235 @@
+const UnitBezier = require('@mapbox/unitbezier');
+
+const interpolate = require('../../util/interpolate');
+const { toString, NumberType } = require('../types');
+const { findStopLessThanOrEqualTo } = require('../stops');
+
+class Interpolate {
+  constructor(type, interpolation, input, stops) {
+    this.type = type;
+    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 [, 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 (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, 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);
+
+    return interpolate[this.type.kind.toLowerCase()](outputLower, 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 = ['interpolate', 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

@@ -0,0 +1,54 @@
+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;