decoders 1.26.0-beta2 → 2.0.0-beta3

package/core/tuple.js

@@ -0,0 +1,173 @@
+"use strict";
+
+exports.__esModule = true;
+exports.tuple1 = tuple1;
+exports.tuple2 = tuple2;
+exports.tuple3 = tuple3;
+exports.tuple4 = tuple4;
+exports.tuple5 = tuple5;
+exports.tuple6 = tuple6;
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+var _result = require("../result");
+
+var _array = require("./array");
+
+var ntuple = function ntuple(n) {
+  return (0, _composition.compose)(_array.poja, (0, _composition.predicate)(function (arr) {
+    return arr.length === n;
+  }, "Must be a " + n + "-tuple"));
+};
+/**
+ * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
+ * Err otherwise.
+ */
+
+
+function tuple1(decoder1) {
+  return (0, _composition.compose)(ntuple(1), function (blobs) {
+    var blob1 = blobs[0];
+    var result1 = decoder1(blob1);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1)]);
+    } catch (e) {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return (0, _result.err)((0, _annotate.annotate)((0, _result.errValue)(result1)));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
+ * for T1 and T2.  Err otherwise.
+ */
+
+
+function tuple2(decoder1, decoder2) {
+  return (0, _composition.compose)(ntuple(2), function (blobs) {
+    var blob1 = blobs[0],
+        blob2 = blobs[1];
+    var result1 = decoder1(blob1);
+    var result2 = decoder2(blob2);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2)]);
+    } catch (e) {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2)]));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
+ * Decoders for T1, T2, and T3.  Err otherwise.
+ */
+
+
+function tuple3(decoder1, decoder2, decoder3) {
+  return (0, _composition.compose)(ntuple(3), function (blobs) {
+    var blob1 = blobs[0],
+        blob2 = blobs[1],
+        blob3 = blobs[2];
+    var result1 = decoder1(blob1);
+    var result2 = decoder2(blob2);
+    var result3 = decoder3(blob3);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3)]);
+    } catch (e) {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3)]));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
+ * Decoders for T1, T2, T3, and T4.  Err otherwise.
+ */
+
+
+function tuple4(decoder1, decoder2, decoder3, decoder4) {
+  return (0, _composition.compose)(ntuple(4), function (blobs) {
+    var blob1 = blobs[0],
+        blob2 = blobs[1],
+        blob3 = blobs[2],
+        blob4 = blobs[3];
+    var result1 = decoder1(blob1);
+    var result2 = decoder2(blob2);
+    var result3 = decoder3(blob3);
+    var result4 = decoder4(blob4);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4)]);
+    } catch (e) {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4)]));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
+ * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
+ */
+
+
+function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
+  return (0, _composition.compose)(ntuple(5), function (blobs) {
+    var blob1 = blobs[0],
+        blob2 = blobs[1],
+        blob3 = blobs[2],
+        blob4 = blobs[3],
+        blob5 = blobs[4];
+    var result1 = decoder1(blob1);
+    var result2 = decoder2(blob2);
+    var result3 = decoder3(blob3);
+    var result4 = decoder4(blob4);
+    var result5 = decoder5(blob5);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5)]);
+    } catch (e) {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5)]));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
+ * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
+ */
+
+
+function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
+  return (0, _composition.compose)(ntuple(6), function (blobs) {
+    var blob1 = blobs[0],
+        blob2 = blobs[1],
+        blob3 = blobs[2],
+        blob4 = blobs[3],
+        blob5 = blobs[4],
+        blob6 = blobs[5];
+    var result1 = decoder1(blob1);
+    var result2 = decoder2(blob2);
+    var result3 = decoder3(blob3);
+    var result4 = decoder4(blob4);
+    var result5 = decoder5(blob5);
+    var result6 = decoder6(blob6);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5), (0, _result.unwrap)(result6)]);
+    } catch (e) {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5), (0, _result.isErr)(result6) ? (0, _result.errValue)(result6) : (0, _result.value)(result6)]));
+    }
+  });
+}

package/core/tuple.js.flow

@@ -0,0 +1,220 @@
+// @flow strict
+
+import { annotate } from '../annotate';
+import { compose, predicate } from './composition';
+import { err, errValue, isErr, ok, unwrap, value } from '../result';
+import { poja } from './array';
+import type { Decoder } from '../_types';
+
+const ntuple = (n: number) =>
+    compose(
+        poja,
+        predicate((arr) => arr.length === n, `Must be a ${n}-tuple`),
+    );
+
+/**
+ * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
+ * Err otherwise.
+ */
+export function tuple1<T>(decoder1: Decoder<T>): Decoder<[T]> {
+    return compose(ntuple(1), (blobs: $ReadOnlyArray<mixed>) => {
+        const [blob1] = blobs;
+
+        const result1 = decoder1(blob1);
+        try {
+            return ok([unwrap(result1)]);
+        } catch (e) {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(annotate(errValue(result1)));
+        }
+    });
+}
+
+/**
+ * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
+ * for T1 and T2.  Err otherwise.
+ */
+export function tuple2<T1, T2>(
+    decoder1: Decoder<T1>,
+    decoder2: Decoder<T2>,
+): Decoder<[T1, T2]> {
+    return compose(ntuple(2), (blobs: $ReadOnlyArray<mixed>) => {
+        const [blob1, blob2] = blobs;
+
+        const result1 = decoder1(blob1);
+        const result2 = decoder2(blob2);
+        try {
+            return ok([unwrap(result1), unwrap(result2)]);
+        } catch (e) {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(
+                annotate([
+                    isErr(result1) ? errValue(result1) : value(result1),
+                    isErr(result2) ? errValue(result2) : value(result2),
+                ]),
+            );
+        }
+    });
+}
+
+/**
+ * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
+ * Decoders for T1, T2, and T3.  Err otherwise.
+ */
+export function tuple3<T1, T2, T3>(
+    decoder1: Decoder<T1>,
+    decoder2: Decoder<T2>,
+    decoder3: Decoder<T3>,
+): Decoder<[T1, T2, T3]> {
+    return compose(ntuple(3), (blobs: $ReadOnlyArray<mixed>) => {
+        const [blob1, blob2, blob3] = blobs;
+
+        const result1 = decoder1(blob1);
+        const result2 = decoder2(blob2);
+        const result3 = decoder3(blob3);
+        try {
+            return ok([unwrap(result1), unwrap(result2), unwrap(result3)]);
+        } catch (e) {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(
+                annotate([
+                    isErr(result1) ? errValue(result1) : value(result1),
+                    isErr(result2) ? errValue(result2) : value(result2),
+                    isErr(result3) ? errValue(result3) : value(result3),
+                ]),
+            );
+        }
+    });
+}
+
+/**
+ * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
+ * Decoders for T1, T2, T3, and T4.  Err otherwise.
+ */
+export function tuple4<T1, T2, T3, T4>(
+    decoder1: Decoder<T1>,
+    decoder2: Decoder<T2>,
+    decoder3: Decoder<T3>,
+    decoder4: Decoder<T4>,
+): Decoder<[T1, T2, T3, T4]> {
+    return compose(ntuple(4), (blobs: $ReadOnlyArray<mixed>) => {
+        const [blob1, blob2, blob3, blob4] = blobs;
+
+        const result1 = decoder1(blob1);
+        const result2 = decoder2(blob2);
+        const result3 = decoder3(blob3);
+        const result4 = decoder4(blob4);
+        try {
+            return ok([
+                unwrap(result1),
+                unwrap(result2),
+                unwrap(result3),
+                unwrap(result4),
+            ]);
+        } catch (e) {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(
+                annotate([
+                    isErr(result1) ? errValue(result1) : value(result1),
+                    isErr(result2) ? errValue(result2) : value(result2),
+                    isErr(result3) ? errValue(result3) : value(result3),
+                    isErr(result4) ? errValue(result4) : value(result4),
+                ]),
+            );
+        }
+    });
+}
+
+/**
+ * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
+ * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
+ */
+export function tuple5<T1, T2, T3, T4, T5>(
+    decoder1: Decoder<T1>,
+    decoder2: Decoder<T2>,
+    decoder3: Decoder<T3>,
+    decoder4: Decoder<T4>,
+    decoder5: Decoder<T5>,
+): Decoder<[T1, T2, T3, T4, T5]> {
+    return compose(ntuple(5), (blobs: $ReadOnlyArray<mixed>) => {
+        const [blob1, blob2, blob3, blob4, blob5] = blobs;
+
+        const result1 = decoder1(blob1);
+        const result2 = decoder2(blob2);
+        const result3 = decoder3(blob3);
+        const result4 = decoder4(blob4);
+        const result5 = decoder5(blob5);
+        try {
+            return ok([
+                unwrap(result1),
+                unwrap(result2),
+                unwrap(result3),
+                unwrap(result4),
+                unwrap(result5),
+            ]);
+        } catch (e) {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(
+                annotate([
+                    isErr(result1) ? errValue(result1) : value(result1),
+                    isErr(result2) ? errValue(result2) : value(result2),
+                    isErr(result3) ? errValue(result3) : value(result3),
+                    isErr(result4) ? errValue(result4) : value(result4),
+                    isErr(result5) ? errValue(result5) : value(result5),
+                ]),
+            );
+        }
+    });
+}
+
+/**
+ * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
+ * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
+ */
+export function tuple6<T1, T2, T3, T4, T5, T6>(
+    decoder1: Decoder<T1>,
+    decoder2: Decoder<T2>,
+    decoder3: Decoder<T3>,
+    decoder4: Decoder<T4>,
+    decoder5: Decoder<T5>,
+    decoder6: Decoder<T6>,
+): Decoder<[T1, T2, T3, T4, T5, T6]> {
+    return compose(ntuple(6), (blobs: $ReadOnlyArray<mixed>) => {
+        const [blob1, blob2, blob3, blob4, blob5, blob6] = blobs;
+
+        const result1 = decoder1(blob1);
+        const result2 = decoder2(blob2);
+        const result3 = decoder3(blob3);
+        const result4 = decoder4(blob4);
+        const result5 = decoder5(blob5);
+        const result6 = decoder6(blob6);
+        try {
+            return ok([
+                unwrap(result1),
+                unwrap(result2),
+                unwrap(result3),
+                unwrap(result4),
+                unwrap(result5),
+                unwrap(result6),
+            ]);
+        } catch (e) {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(
+                annotate([
+                    isErr(result1) ? errValue(result1) : value(result1),
+                    isErr(result2) ? errValue(result2) : value(result2),
+                    isErr(result3) ? errValue(result3) : value(result3),
+                    isErr(result4) ? errValue(result4) : value(result4),
+                    isErr(result5) ? errValue(result5) : value(result5),
+                    isErr(result6) ? errValue(result6) : value(result6),
+                ]),
+            );
+        }
+    });
+}

package/format/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.formatShort = exports.formatInline = void 0;
+
+var _inline = require("./inline");
+
+exports.formatInline = _inline.formatInline;
+
+var _short = require("./short");
+
+exports.formatShort = _short.formatShort;

package/format/index.js.flow

@@ -0,0 +1,4 @@
+// @flow strict
+
+export { formatInline } from './inline';
+export { formatShort } from './short';

package/format/inline.js

@@ -0,0 +1,146 @@
+"use strict";
+
+exports.__esModule = true;
+exports.formatInline = formatInline;
+exports.serializeAnnotation = serializeAnnotation;
+exports.serializeValue = serializeValue;
+
+var _utils = require("../_utils");
+
+function serializeString(s, width) {
+  if (width === void 0) {
+    width = 80;
+  }
+
+  // Full string
+  // Abbreviated to $maxlen i.e. "Vincent Driess..." [truncated]
+  var ser = JSON.stringify(s);
+
+  if (ser.length <= width) {
+    return ser;
+  } // Cut off a bit
+
+
+  var truncated = s.substring(0, width - 15) + '...';
+  ser = JSON.stringify(truncated) + ' [truncated]';
+  return ser;
+}
+
+function serializeArray(annotation, prefix) {
+  var items = annotation.items;
+
+  if (items.length === 0) {
+    return '[]';
+  }
+
+  var result = [];
+  items.forEach(function (item) {
+    var _serializeAnnotation = serializeAnnotation(item, prefix + _utils.INDENT),
+        ser = _serializeAnnotation[0],
+        ann = _serializeAnnotation[1];
+
+    result.push(prefix + _utils.INDENT + ser + ',');
+
+    if (ann !== undefined) {
+      result.push((0, _utils.indent)(ann, prefix + _utils.INDENT));
+    }
+  });
+  return ['['].concat(result, [prefix + ']']).join('\n');
+}
+
+function serializeObject(annotation, prefix) {
+  var fields = annotation.fields;
+  var fieldNames = Object.keys(fields);
+
+  if (fieldNames.length === 0) {
+    return '{}';
+  }
+
+  var result = [];
+  fieldNames.forEach(function (key) {
+    var valueAnnotation = fields[key];
+    var kser = serializeValue(key);
+    var valPrefix = prefix + _utils.INDENT + ' '.repeat(kser.length + 2);
+
+    var _serializeAnnotation2 = serializeAnnotation(valueAnnotation, prefix + _utils.INDENT),
+        vser = _serializeAnnotation2[0],
+        vann = _serializeAnnotation2[1];
+
+    result.push(prefix + _utils.INDENT + kser + ': ' + vser + ',');
+
+    if (vann !== undefined) {
+      result.push((0, _utils.indent)(vann, valPrefix));
+    }
+  });
+  return ['{'].concat(result, [prefix + '}']).join('\n');
+}
+
+function serializeValue(value) {
+  // istanbul ignore else
+  if (typeof value === 'string') {
+    return serializeString(value);
+  } else if (typeof value === 'number' || typeof value === 'boolean') {
+    return value.toString();
+  } else if (value === null) {
+    return 'null';
+  } else if (value === undefined) {
+    return 'undefined';
+  } else {
+    var valueAsDate = (0, _utils.asDate)(value);
+
+    if (valueAsDate !== null) {
+      return "new Date(" + JSON.stringify(valueAsDate.toISOString()) + ")";
+    } else if (value instanceof Date) {
+      // NOTE: Using `instanceof Date` is unreliable way of checking dates.
+      // If this case occurs (and it didn't pass the prior isDate())
+      // check, then this must be the case where it's an invalid date.
+      return '(Invalid Date)';
+    } else {
+      return '(unserializable)';
+    }
+  }
+}
+
+function serializeAnnotation(ann, prefix) {
+  if (prefix === void 0) {
+    prefix = '';
+  }
+
+  // The serialized data (the input object echoed back)
+  var serialized;
+
+  if (ann.type === 'array') {
+    serialized = serializeArray(ann, prefix);
+  } else if (ann.type === 'object') {
+    serialized = serializeObject(ann, prefix);
+  } else if (ann.type === 'function') {
+    serialized = '<function>';
+  } else if (ann.type === 'circular-ref') {
+    serialized = '<circular ref>';
+  } else if (ann.type === 'unknown') {
+    serialized = '???';
+  } else {
+    serialized = serializeValue(ann.value);
+  }
+
+  var text = ann.text;
+
+  if (text !== undefined) {
+    var sep = '^'.repeat((0, _utils.isMultiline)(serialized) ? 1 : serialized.length);
+    return [serialized, [sep, text].join((0, _utils.isMultiline)(text) ? '\n' : ' ')];
+  } else {
+    return [serialized, undefined];
+  }
+}
+
+function formatInline(ann) {
+  var _serializeAnnotation3 = serializeAnnotation(ann),
+      serialized = _serializeAnnotation3[0],
+      annotation = _serializeAnnotation3[1];
+
+  if (annotation !== undefined) {
+    return serialized + '\n' + annotation;
+  } else {
+    return serialized;
+  }
+}

package/format/inline.js.flow

@@ -0,0 +1,122 @@
+// @flow strict
+
+import { asDate, indent, INDENT, isMultiline } from '../_utils';
+import type { Annotation, ArrayAnnotation, ObjectAnnotation } from '../annotate';
+
+function serializeString(s: string, width: number = 80): string {
+    // Full string
+    // Abbreviated to $maxlen i.e. "Vincent Driess..." [truncated]
+    let ser = JSON.stringify(s);
+    if (ser.length <= width) {
+        return ser;
+    }
+
+    // Cut off a bit
+    const truncated = s.substring(0, width - 15) + '...';
+    ser = JSON.stringify(truncated) + ' [truncated]';
+    return ser;
+}
+
+function serializeArray(annotation: ArrayAnnotation, prefix: string): string {
+    const { items } = annotation;
+    if (items.length === 0) {
+        return '[]';
+    }
+
+    const result = [];
+    items.forEach((item) => {
+        const [ser, ann] = serializeAnnotation(item, prefix + INDENT);
+        result.push(prefix + INDENT + ser + ',');
+        if (ann !== undefined) {
+            result.push(indent(ann, prefix + INDENT));
+        }
+    });
+    return ['[', ...result, prefix + ']'].join('\n');
+}
+
+function serializeObject(annotation: ObjectAnnotation, prefix: string): string {
+    const { fields } = annotation;
+
+    const fieldNames = Object.keys(fields);
+    if (fieldNames.length === 0) {
+        return '{}';
+    }
+
+    const result = [];
+    fieldNames.forEach((key) => {
+        const valueAnnotation = fields[key];
+        const kser = serializeValue(key);
+
+        const valPrefix = prefix + INDENT + ' '.repeat(kser.length + 2);
+        const [vser, vann] = serializeAnnotation(valueAnnotation, prefix + INDENT);
+
+        result.push(prefix + INDENT + kser + ': ' + vser + ',');
+        if (vann !== undefined) {
+            result.push(indent(vann, valPrefix));
+        }
+    });
+    return ['{', ...result, prefix + '}'].join('\n');
+}
+
+export function serializeValue(value: mixed): string {
+    // istanbul ignore else
+    if (typeof value === 'string') {
+        return serializeString(value);
+    } else if (typeof value === 'number' || typeof value === 'boolean') {
+        return value.toString();
+    } else if (value === null) {
+        return 'null';
+    } else if (value === undefined) {
+        return 'undefined';
+    } else {
+        const valueAsDate = asDate(value);
+        if (valueAsDate !== null) {
+            return `new Date(${JSON.stringify(valueAsDate.toISOString())})`;
+        } else if (value instanceof Date) {
+            // NOTE: Using `instanceof Date` is unreliable way of checking dates.
+            // If this case occurs (and it didn't pass the prior isDate())
+            // check, then this must be the case where it's an invalid date.
+            return '(Invalid Date)';
+        } else {
+            return '(unserializable)';
+        }
+    }
+}
+
+export function serializeAnnotation(
+    ann: Annotation,
+    prefix: string = '',
+): [string, string | void] {
+    // The serialized data (the input object echoed back)
+    let serialized;
+    if (ann.type === 'array') {
+        serialized = serializeArray(ann, prefix);
+    } else if (ann.type === 'object') {
+        serialized = serializeObject(ann, prefix);
+    } else if (ann.type === 'function') {
+        serialized = '<function>';
+    } else if (ann.type === 'circular-ref') {
+        serialized = '<circular ref>';
+    } else if (ann.type === 'unknown') {
+        serialized = '???';
+    } else {
+        serialized = serializeValue(ann.value);
+    }
+
+    const text = ann.text;
+    if (text !== undefined) {
+        const sep = '^'.repeat(isMultiline(serialized) ? 1 : serialized.length);
+        return [serialized, [sep, text].join(isMultiline(text) ? '\n' : ' ')];
+    } else {
+        return [serialized, undefined];
+    }
+}
+
+export function formatInline(ann: Annotation): string {
+    const [serialized, annotation] = serializeAnnotation(ann);
+    if (annotation !== undefined) {
+        return serialized + '\n' + annotation;
+    } else {
+        return serialized;
+    }
+}

package/format/short.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.formatShort = formatShort;
+
+var _utils = require("../_utils");
+
+function formatShort(ann) {
+  return (0, _utils.summarize)(ann, []).join('\n');
+}

package/format/short.js.flow

@@ -0,0 +1,8 @@
+// @flow strict
+
+import { summarize as _summarize } from '../_utils';
+import type { Annotation } from '../annotate';
+
+export function formatShort(ann: Annotation): string {
+    return _summarize(ann, []).join('\n');
+}