@uniflowed/validator 0.34.0 → 0.36.0

package/action.js

@@ -81,7 +81,7 @@ export function length(value: number): Step<string, string> {
 export function nonEmpty(): Step<string, string> {
   return <TInput>(schema: Schema<string, TInput>): Schema<string, TInput> =>
     refine(schema, (input: string) => input.length > 0, "non_empty", "expected a value", {
-      kind: "minLength",
+      kind : "minLength",
       value: 1,
     });
 }

package/collection.js

@@ -111,7 +111,7 @@ export function tuple<TItems extends Options>(
   const arity = items.length;
   const message = `expected ${String(arity)} tuple items`;
   const description = (): Description => ({
-    kind: "tuple",
+    kind : "tuple",
     items: items.map((item) => describe(item)),
   });
 
@@ -220,12 +220,12 @@ export function record<TOutput, TInput>(
  * halfway through.
  */
 export function map<TKey, TKeyInput, TValue, TValueInput>(
-  key: Schema<TKey, TKeyInput>,
+  key  : Schema<TKey, TKeyInput>,
   value: Schema<TValue, TValueInput>,
 ): Schema<$ReadOnlyMap<TKey, TValue>, $ReadOnlyMap<TKeyInput, TValueInput>> {
   const description = (): Description => ({
-    kind: "map",
-    key: describe(key),
+    kind : "map",
+    key  : describe(key),
     value: describe(value),
   });
 
@@ -298,9 +298,9 @@ export function set<TOutput, TInput>(
       }
       const collected = await collectAsync(
         Array.from(value).map((member, index) => ({
-          keys: [String(index)],
+          keys  : [String(index)],
           schema: item,
-          value: member,
+          value : member,
         })),
         path,
       );

package/issue.js

@@ -51,9 +51,9 @@ export type PathBuffer = Array<string>;
  * with one fewer field is one fewer allocation on the path that matters.
  */
 export type Issue = {|
-  readonly code: string,
+  readonly code   : string,
   readonly message: string,
-  readonly path?: Path,
+  readonly path?  : Path,
 |};
 
 /**
@@ -103,7 +103,7 @@ export class ValidationError extends Error {
  * reaches this function as a path segment.
  */
 export type FlatIssues = {|
-  readonly root: $ReadOnlyArray<string>,
+  readonly root  : $ReadOnlyArray<string>,
   readonly nested: { readonly [string]: $ReadOnlyArray<string>, ... },
 |};
 

package/json-schema.js

@@ -84,7 +84,7 @@ export type Unrepresentable = {|
 
 /** A JSON Schema document, and everything JSON Schema could not say. */
 export type JsonSchemaExport = {|
-  readonly schema: JsonSchemaNode,
+  readonly schema         : JsonSchemaNode,
   readonly unrepresentable: $ReadOnlyArray<Unrepresentable>,
 |};
 
@@ -113,13 +113,13 @@ function merge(left: JsonSchemaNode, right: JsonSchemaNode): JsonSchemaNode {
  */
 function mayBeAbsent(description: Description): boolean {
   return match (description) {
-    {kind: "optional", inner: _} => true,
-    {kind: "nullish", inner: _} => true,
-    {kind: "default", inner: _} => true,
-    {kind: "fallback", inner: _} => true,
+    {kind: "optional", inner: _}                             => true,
+    {kind: "nullish", inner: _}                              => true,
+    {kind: "default", inner: _}                              => true,
+    {kind: "fallback", inner: _}                             => true,
     {kind: "constrained", inner: const inner, constraint: _} => mayBeAbsent(inner),
-    {kind: "transformed", inner: const inner} => mayBeAbsent(inner),
-    _ => false,
+    {kind: "transformed", inner: const inner}                => mayBeAbsent(inner),
+    _                                                        => false,
   };
 }
 
@@ -132,9 +132,9 @@ function mayBeAbsent(description: Description): boolean {
  */
 function describesTransformedValue(description: Description): boolean {
   return match (description) {
-    {kind: "transformed", inner: _} => true,
+    {kind: "transformed", inner: _}                          => true,
     {kind: "constrained", inner: const inner, constraint: _} => describesTransformedValue(inner),
-    _ => false,
+    _                                                        => false,
   };
 }
 
@@ -146,19 +146,19 @@ function labelFor(constraint: Constraint): string {
 /** The JSON Schema keywords one `pipe` step contributes, if any. */
 function keywordsFor(constraint: Constraint): JsonSchemaNode {
   return match (constraint) {
-    {kind: "minLength", value: const value} => { minLength: value },
-    {kind: "maxLength", value: const value} => { maxLength: value },
-    {kind: "length", value: const value} => { minLength: value, maxLength: value },
-    {kind: "minItems", value: const value} => { minItems: value },
-    {kind: "maxItems", value: const value} => { maxItems: value },
-    {kind: "min", value: const value} => { minimum: value },
-    {kind: "max", value: const value} => { maximum: value },
-    {kind: "integer"} => { type: "integer" },
+    {kind: "minLength", value: const value}  => { minLength: value },
+    {kind: "maxLength", value: const value}  => { maxLength: value },
+    {kind: "length", value: const value}     => { minLength: value, maxLength: value },
+    {kind: "minItems", value: const value}   => { minItems: value },
+    {kind: "maxItems", value: const value}   => { maxItems: value },
+    {kind: "min", value: const value}        => { minimum: value },
+    {kind: "max", value: const value}        => { maximum: value },
+    {kind: "integer"}                        => { type: "integer" },
     {kind: "multipleOf", value: const value} => { multipleOf: value },
-    {kind: "pattern", source: const source} => { pattern: source },
-    {kind: "format", name: const name} => { format: name },
-    {kind: "brand", name: const name} => { title: name },
-    {kind: "opaque", label: _} => {},
+    {kind: "pattern", source: const source}  => { pattern: source },
+    {kind: "format", name: const name}       => { format: name },
+    {kind: "brand", name: const name}        => { title: name },
+    {kind: "opaque", label: _}               => {},
   };
 }
 
@@ -181,9 +181,9 @@ export function toJsonSchema(schema: Schema<mixed, mixed>): JsonSchemaExport {
   }
 
   function object(
-    entries: $ReadOnlyArray<[string, Description]>,
+    entries    : $ReadOnlyArray<[string, Description]>,
     unknownKeys: "strip" | "reject" | "keep",
-    path: Path,
+    path       : Path,
   ): JsonSchemaNode {
     const properties: { [string]: JsonSchemaNode, ... } = {};
     const required: Array<string> = [];
@@ -210,66 +210,66 @@ export function toJsonSchema(schema: Schema<mixed, mixed>): JsonSchemaExport {
 
   function convert(description: Description, path: Path): JsonSchemaNode {
     return match (description) {
-      {kind: "unknown"} => {},
-      {kind: "never"} => { not: {} },
-      {kind: "string"} => { type: "string" },
-      {kind: "number"} => { type: "number" },
-      {kind: "boolean"} => { type: "boolean" },
-      {kind: "null"} => { type: "null" },
-      {kind: "bigint"} => unsupported("bigint", path),
-      {kind: "undefined"} => unsupported("undefined", path),
-      {kind: "date"} => unsupported("date", path),
-      {kind: "instance", name: const name} => unsupported(`instance ${name}`, path),
-      {kind: "custom", name: const name} => unsupported(`custom ${name}`, path),
-      {kind: "map", key: _, value: _} => unsupported("map", path),
-      {kind: "set", item: _} => unsupported("set", path),
-      {kind: "literal", value: const value} => { const: value },
-      {kind: "enum", values: const values} => { enum: values.slice() },
-      {kind: "array", item: const item} =>
+      {kind: "unknown"}                                                        => {},
+      {kind: "never"}                                                          => { not: {} },
+      {kind: "string"}                                                         => { type: "string" },
+      {kind: "number"}                                                         => { type: "number" },
+      {kind: "boolean"}                                                        => { type: "boolean" },
+      {kind: "null"}                                                           => { type: "null" },
+      {kind: "bigint"}                                                         => unsupported("bigint", path),
+      {kind: "undefined"}                                                      => unsupported("undefined", path),
+      {kind: "date"}                                                           => unsupported("date", path),
+      {kind: "instance", name: const name}                                     => unsupported(`instance ${name}`, path),
+      {kind: "custom", name: const name}                                       => unsupported(`custom ${name}`, path),
+      {kind: "map", key: _, value: _}                                          => unsupported("map", path),
+      {kind: "set", item: _}                                                   => unsupported("set", path),
+      {kind: "literal", value: const value}                                    => { const: value },
+      {kind: "enum", values: const values}                                     => { enum: values.slice() },
+      {kind: "array", item: const item}                                        =>
         {
-          type: "array",
+          type : "array",
           items: convert(item, path.concat("*")),
         },
-      {kind: "tuple", items: const items} =>
+      {kind: "tuple", items: const items}                                      =>
         {
-          type: "array",
+          type       : "array",
           prefixItems: items.map((item, index) => convert(item, path.concat(String(index)))),
-          minItems: items.length,
-          maxItems: items.length,
+          minItems   : items.length,
+          maxItems   : items.length,
         },
-      {kind: "record", value: const value} =>
+      {kind: "record", value: const value}                                     =>
         {
-          type: "object",
+          type                : "object",
           additionalProperties: convert(value, path.concat("*")),
         },
       {kind: "object", entries: const entries, unknownKeys: const unknownKeys} =>
         object(entries, unknownKeys, path),
-      {kind: "union", options: const options} =>
+      {kind: "union", options: const options}                                  =>
         {
           anyOf: options.map((option) => convert(option, path)),
         },
-      {kind: "variant", key: _, branches: const branches} =>
+      {kind: "variant", key: _, branches: const branches}                      =>
         {
           oneOf: branches.map(([, branch]) => convert(branch, path)),
         },
-      {kind: "intersect", parts: const parts} =>
+      {kind: "intersect", parts: const parts}                                  =>
         {
           allOf: parts.map((part) => convert(part, path)),
         },
-      {kind: "optional", inner: const inner} => convert(inner, path),
-      {kind: "default", inner: const inner} => convert(inner, path),
-      {kind: "nullable", inner: const inner} =>
+      {kind: "optional", inner: const inner}                                   => convert(inner, path),
+      {kind: "default", inner: const inner}                                    => convert(inner, path),
+      {kind: "nullable", inner: const inner}                                   =>
         {
           anyOf: [convert(inner, path), { type: "null" }],
         },
-      {kind: "nullish", inner: const inner} =>
+      {kind: "nullish", inner: const inner}                                    =>
         {
           anyOf: [convert(inner, path), { type: "null" }],
         },
-      {kind: "fallback", inner: _} => {},
-      {kind: "transformed", inner: const inner} => convert(inner, path),
-      {kind: "lazy", id: const id, inner: const inner} => recursive(id, inner, path),
-      {kind: "constrained", inner: const inner, constraint: const constraint} =>
+      {kind: "fallback", inner: _}                                             => {},
+      {kind: "transformed", inner: const inner}                                => convert(inner, path),
+      {kind: "lazy", id: const id, inner: const inner}                         => recursive(id, inner, path),
+      {kind: "constrained", inner: const inner, constraint: const constraint}  =>
         constrained(inner, constraint, path),
     };
   }

package/namespace.js

@@ -83,77 +83,77 @@ import { describe, isAsync } from "./schema.js";
 import { intersect, union, variant } from "./union.js";
 
 export const v: {
-  readonly string: typeof string,
-  readonly number: typeof number,
-  readonly bigint: typeof bigint,
-  readonly boolean: typeof boolean,
-  readonly unknown: typeof unknown,
-  readonly never: typeof never,
-  readonly null: typeof null_,
-  readonly undefined: typeof undefined_,
-  readonly literal: typeof literal,
-  readonly enum: typeof enum_,
-  readonly date: typeof date,
-  readonly instance: typeof instance,
-  readonly custom: typeof custom,
-  readonly object: typeof object,
-  readonly strictObject: typeof strictObject,
-  readonly looseObject: typeof looseObject,
-  readonly partial: typeof partial,
-  readonly array: typeof array,
-  readonly tuple: typeof tuple,
-  readonly record: typeof record,
-  readonly map: typeof map,
-  readonly set: typeof set,
-  readonly union: typeof union,
-  readonly variant: typeof variant,
-  readonly intersect: typeof intersect,
-  readonly optional: typeof optional,
-  readonly nullable: typeof nullable,
-  readonly nullish: typeof nullish,
-  readonly withDefault: typeof withDefault,
-  readonly fallback: typeof fallback,
-  readonly lazy: typeof lazy,
-  readonly lazyAsync: typeof lazyAsync,
-  readonly pipe: typeof pipe,
-  readonly check: typeof check,
-  readonly checkAsync: typeof checkAsync,
-  readonly transform: typeof transform,
+  readonly string        : typeof string,
+  readonly number        : typeof number,
+  readonly bigint        : typeof bigint,
+  readonly boolean       : typeof boolean,
+  readonly unknown       : typeof unknown,
+  readonly never         : typeof never,
+  readonly null          : typeof null_,
+  readonly undefined     : typeof undefined_,
+  readonly literal       : typeof literal,
+  readonly enum          : typeof enum_,
+  readonly date          : typeof date,
+  readonly instance      : typeof instance,
+  readonly custom        : typeof custom,
+  readonly object        : typeof object,
+  readonly strictObject  : typeof strictObject,
+  readonly looseObject   : typeof looseObject,
+  readonly partial       : typeof partial,
+  readonly array         : typeof array,
+  readonly tuple         : typeof tuple,
+  readonly record        : typeof record,
+  readonly map           : typeof map,
+  readonly set           : typeof set,
+  readonly union         : typeof union,
+  readonly variant       : typeof variant,
+  readonly intersect     : typeof intersect,
+  readonly optional      : typeof optional,
+  readonly nullable      : typeof nullable,
+  readonly nullish       : typeof nullish,
+  readonly withDefault   : typeof withDefault,
+  readonly fallback      : typeof fallback,
+  readonly lazy          : typeof lazy,
+  readonly lazyAsync     : typeof lazyAsync,
+  readonly pipe          : typeof pipe,
+  readonly check         : typeof check,
+  readonly checkAsync    : typeof checkAsync,
+  readonly transform     : typeof transform,
   readonly transformAsync: typeof transformAsync,
-  readonly brand: typeof brand,
-  readonly refine: typeof refine,
-  readonly minLength: typeof minLength,
-  readonly maxLength: typeof maxLength,
-  readonly length: typeof length,
-  readonly nonEmpty: typeof nonEmpty,
-  readonly startsWith: typeof startsWith,
-  readonly endsWith: typeof endsWith,
-  readonly includes: typeof includes,
-  readonly regex: typeof regex,
-  readonly email: typeof email,
-  readonly url: typeof url,
-  readonly uuid: typeof uuid,
-  readonly isoDate: typeof isoDate,
-  readonly trim: typeof trim,
-  readonly toLowerCase: typeof toLowerCase,
-  readonly toUpperCase: typeof toUpperCase,
-  readonly min: typeof min,
-  readonly max: typeof max,
-  readonly integer: typeof integer,
-  readonly multipleOf: typeof multipleOf,
-  readonly minItems: typeof minItems,
-  readonly maxItems: typeof maxItems,
-  readonly parse: typeof parse,
-  readonly safeParse: typeof safeParse,
-  readonly parseAsync: typeof parseAsync,
+  readonly brand         : typeof brand,
+  readonly refine        : typeof refine,
+  readonly minLength     : typeof minLength,
+  readonly maxLength     : typeof maxLength,
+  readonly length        : typeof length,
+  readonly nonEmpty      : typeof nonEmpty,
+  readonly startsWith    : typeof startsWith,
+  readonly endsWith      : typeof endsWith,
+  readonly includes      : typeof includes,
+  readonly regex         : typeof regex,
+  readonly email         : typeof email,
+  readonly url           : typeof url,
+  readonly uuid          : typeof uuid,
+  readonly isoDate       : typeof isoDate,
+  readonly trim          : typeof trim,
+  readonly toLowerCase   : typeof toLowerCase,
+  readonly toUpperCase   : typeof toUpperCase,
+  readonly min           : typeof min,
+  readonly max           : typeof max,
+  readonly integer       : typeof integer,
+  readonly multipleOf    : typeof multipleOf,
+  readonly minItems      : typeof minItems,
+  readonly maxItems      : typeof maxItems,
+  readonly parse         : typeof parse,
+  readonly safeParse     : typeof safeParse,
+  readonly parseAsync    : typeof parseAsync,
   readonly safeParseAsync: typeof safeParseAsync,
-  readonly is: typeof is,
-  readonly parser: typeof parser,
-  readonly useValidation: typeof useValidation,
-  readonly describe: typeof describe,
-  readonly isAsync: typeof isAsync,
-  readonly flatten: typeof flatten,
-  readonly toJsonSchema: typeof toJsonSchema,
+  readonly is            : typeof is,
+  readonly parser        : typeof parser,
+  readonly useValidation : typeof useValidation,
+  readonly describe      : typeof describe,
+  readonly isAsync       : typeof isAsync,
+  readonly flatten       : typeof flatten,
+  readonly toJsonSchema  : typeof toJsonSchema,
 } = {
   string,
   number,
@@ -161,7 +161,7 @@ export const v: {
   boolean,
   unknown,
   never,
-  null: null_,
+  null     : null_,
   undefined: undefined_,
   literal,
   enum: enum_,

package/object.js

@@ -76,8 +76,8 @@ function shapeEntries(shape: Shape): $ReadOnlyArray<[string, Schema<mixed, mixed
 /** Issues for every own key the shape does not name. Empty unless rejecting. */
 function unknownKeyIssues(
   source: { readonly [string]: mixed, ... },
-  named: Set<string>,
-  path: PathBuffer,
+  named : Set<string>,
+  path  : PathBuffer,
 ): Array<Issue> {
   const issues: Array<Issue> = [];
   for (const key of ownKeys(source)) {
@@ -93,8 +93,8 @@ function unknownKeyIssues(
 /** Copy every own key the shape does not name into the output, unchecked. */
 function keepUnknownKeys(
   source: { readonly [string]: mixed, ... },
-  named: Set<string>,
-  out: { [string]: mixed, ... },
+  named : Set<string>,
+  out   : { [string]: mixed, ... },
 ): void {
   for (const key of ownKeys(source)) {
     if (!named.has(key)) {
@@ -111,22 +111,22 @@ function keepUnknownKeys(
  * exact result, a `Partial` one and an inexact one alike.
  */
 function buildObject<TOutput, TInput>(
-  shape: Shape,
+  shape      : Shape,
   unknownKeys: UnknownKeys,
 ): Schema<TOutput, TInput> {
   const entries = shapeEntries(shape);
   const named = new Set(entries.map(([key]) => key));
   const description = (): Description => ({
-    kind: "object",
+    kind   : "object",
     entries: entries.map(([key, schema]) => [key, describe(schema)]),
     unknownKeys,
   });
 
   function assemble(
     source: { readonly [string]: mixed, ... },
-    out: { [string]: mixed, ... },
-    found: Array<Issue>,
-    path: PathBuffer,
+    out   : { [string]: mixed, ... },
+    found : Array<Issue>,
+    path  : PathBuffer,
   ): Result<TOutput> {
     const issues =
       unknownKeys === "reject" ? found.concat(unknownKeyIssues(source, named, path)) : found;
@@ -153,7 +153,7 @@ function buildObject<TOutput, TInput>(
       const out: { [string]: mixed, ... } = {};
       const found: Array<Issue> = [];
       match (collected) {
-        {ok: true, values: const values} => {
+        {ok: true, values: const values}           => {
           entries.forEach(([key], index) => {
             put(out, key, values[index]);
           });

package/optional.js

@@ -39,8 +39,8 @@ import { describe, isAsync, makeAsyncSchema, makeSchema, ok, run, runAsync } fro
  * same three lines.
  */
 function wrap<TOutput, TInput>(
-  inner: Schema<TOutput, mixed>,
-  shortcut: (value: mixed) => null | Result<TOutput>,
+  inner      : Schema<TOutput, mixed>,
+  shortcut   : (value: mixed) => null | Result<TOutput>,
   description: () => Description,
 ): Schema<TOutput, TInput> {
   if (isAsync(inner)) {
@@ -97,7 +97,7 @@ export function nullish<TOutput, TInput>(
  */
 export function withDefault<TOutput, TInput>(
   schema: Schema<TOutput, TInput>,
-  value: TOutput,
+  value : TOutput,
 ): Schema<TOutput, void | TInput> {
   return wrap(
     schema,
@@ -116,7 +116,7 @@ export function withDefault<TOutput, TInput>(
  */
 export function fallback<TOutput>(
   schema: Schema<TOutput, mixed>,
-  value: TOutput,
+  value : TOutput,
 ): Schema<TOutput, mixed> {
   const description = (): Description => ({ kind: "fallback", inner: describe(schema) });
   if (isAsync(schema)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/validator",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Schemas that parse rather than assert: typed inference, issue paths and JSON Schema export, part of the Unified Toolchain for Flow.",
   "type": "module",
   "license": "MIT",

package/parse.js

@@ -58,7 +58,7 @@ export function parse<TOutput>(schema: Schema<TOutput, mixed>, value: mixed): TO
 /** [`safeParse`], for a schema with something to wait for. */
 export function safeParseAsync<TOutput>(
   schema: Schema<TOutput, mixed>,
-  value: mixed,
+  value : mixed,
 ): Promise<Result<TOutput>> {
   return runAsync(schema, value, []);
 }
@@ -66,7 +66,7 @@ export function safeParseAsync<TOutput>(
 /** [`parse`], for a schema with something to wait for. */
 export async function parseAsync<TOutput>(
   schema: Schema<TOutput, mixed>,
-  value: mixed,
+  value : mixed,
 ): Promise<TOutput> {
   const result = await safeParseAsync(schema, value);
   if (result.ok) {

package/pipe.js

@@ -79,60 +79,60 @@ export type Pipe = {
   <A, AIn, B, C>(schema: Schema<A, AIn>, a: Step<A, B>, b: Step<B, C>): Schema<C, AIn>,
   <A, AIn, B, C, D>(
     schema: Schema<A, AIn>,
-    a: Step<A, B>,
-    b: Step<B, C>,
-    c: Step<C, D>,
+    a     : Step<A, B>,
+    b     : Step<B, C>,
+    c     : Step<C, D>,
   ): Schema<D, AIn>,
   <A, AIn, B, C, D, E>(
     schema: Schema<A, AIn>,
-    a: Step<A, B>,
-    b: Step<B, C>,
-    c: Step<C, D>,
-    d: Step<D, E>,
+    a     : Step<A, B>,
+    b     : Step<B, C>,
+    c     : Step<C, D>,
+    d     : Step<D, E>,
   ): Schema<E, AIn>,
   <A, AIn, B, C, D, E, F>(
     schema: Schema<A, AIn>,
-    a: Step<A, B>,
-    b: Step<B, C>,
-    c: Step<C, D>,
-    d: Step<D, E>,
-    e: Step<E, F>,
+    a     : Step<A, B>,
+    b     : Step<B, C>,
+    c     : Step<C, D>,
+    d     : Step<D, E>,
+    e     : Step<E, F>,
   ): Schema<F, AIn>,
   <A, AIn, B, C, D, E, F, G>(
     schema: Schema<A, AIn>,
-    a: Step<A, B>,
-    b: Step<B, C>,
-    c: Step<C, D>,
-    d: Step<D, E>,
-    e: Step<E, F>,
-    f: Step<F, G>,
+    a     : Step<A, B>,
+    b     : Step<B, C>,
+    c     : Step<C, D>,
+    d     : Step<D, E>,
+    e     : Step<E, F>,
+    f     : Step<F, G>,
   ): Schema<G, AIn>,
   <A, AIn, B, C, D, E, F, G, H>(
     schema: Schema<A, AIn>,
-    a: Step<A, B>,
-    b: Step<B, C>,
-    c: Step<C, D>,
-    d: Step<D, E>,
-    e: Step<E, F>,
-    f: Step<F, G>,
-    g: Step<G, H>,
+    a     : Step<A, B>,
+    b     : Step<B, C>,
+    c     : Step<C, D>,
+    d     : Step<D, E>,
+    e     : Step<E, F>,
+    f     : Step<F, G>,
+    g     : Step<G, H>,
   ): Schema<H, AIn>,
   <A, AIn, B, C, D, E, F, G, H, I>(
     schema: Schema<A, AIn>,
-    a: Step<A, B>,
-    b: Step<B, C>,
-    c: Step<C, D>,
-    d: Step<D, E>,
-    e: Step<E, F>,
-    f: Step<F, G>,
-    g: Step<G, H>,
-    h: Step<H, I>,
+    a     : Step<A, B>,
+    b     : Step<B, C>,
+    c     : Step<C, D>,
+    d     : Step<D, E>,
+    e     : Step<E, F>,
+    f     : Step<F, G>,
+    g     : Step<G, H>,
+    h     : Step<H, I>,
   ): Schema<I, AIn>,
   ...
 };
 
 function applySteps<TInput>(
-  schema: Schema<mixed, TInput>,
+  schema  : Schema<mixed, TInput>,
   ...steps: $ReadOnlyArray<Step<mixed, mixed>>
 ): Schema<mixed, TInput> {
   let piped = schema;
@@ -154,15 +154,15 @@ export const pipe: Pipe = applySteps as Pipe;
  * what it refined is invisible to every exporter.
  */
 export function refine<TOutput, TInput>(
-  schema: Schema<TOutput, TInput>,
-  accepts: (value: TOutput) => boolean,
-  code: string,
-  message: string,
+  schema    : Schema<TOutput, TInput>,
+  accepts   : (value: TOutput) => boolean,
+  code      : string,
+  message   : string,
   constraint: Constraint,
-  at: Path = [],
+  at        : Path = [],
 ): Schema<TOutput, TInput> {
   const description = (): Description => ({
-    kind: "constrained",
+    kind : "constrained",
     inner: describe(schema),
     constraint,
   });
@@ -200,7 +200,7 @@ export function refine<TOutput, TInput>(
 export function check<TValue>(
   accepts: (value: TValue) => boolean,
   message: string,
-  at: Path = [],
+  at     : Path = [],
 ): Step<TValue, TValue> {
   return <TInput>(schema: Schema<TValue, TInput>): Schema<TValue, TInput> =>
     refine(schema, accepts, "check", message, { kind: "opaque", label: message }, at);
@@ -217,7 +217,7 @@ export function check<TValue>(
 export function checkAsync<TValue>(
   accepts: (value: TValue) => Promise<boolean>,
   message: string,
-  at: Path = [],
+  at     : Path = [],
 ): Step<TValue, TValue> {
   return <TInput>(schema: Schema<TValue, TInput>): Schema<TValue, TInput> =>
     makeAsyncSchema(
@@ -231,8 +231,8 @@ export function checkAsync<TValue>(
           : { ok: false, issues: [issueUnder("check", message, path, at)] };
       },
       () => ({
-        kind: "constrained",
-        inner: describe(schema),
+        kind      : "constrained",
+        inner     : describe(schema),
         constraint: { kind: "opaque", label: message },
       }),
     );
@@ -288,8 +288,8 @@ export function transformAsync<TFrom, TTo>(
 export function brand<TValue>(name: string): Step<TValue, TValue> {
   return <TInput>(schema: Schema<TValue, TInput>): Schema<TValue, TInput> => {
     const description = (): Description => ({
-      kind: "constrained",
-      inner: describe(schema),
+      kind      : "constrained",
+      inner     : describe(schema),
       constraint: { kind: "brand", name },
     });
     if (isAsync(schema)) {

package/plain-object.js

@@ -98,8 +98,8 @@ export function put<Value>(out: { [string]: Value, ... }, key: string, value: Va
   }
   Object.defineProperty(out, key, {
     value,
-    writable: true,
-    enumerable: true,
+    writable    : true,
+    enumerable  : true,
     configurable: true,
   });
 }

package/primitive.js

@@ -172,7 +172,7 @@ export function instance<TValue>(ClassValue: Class<TValue>): Schema<TValue, TVal
 export function custom<TValue>(
   accepts: (value: mixed) => boolean,
   message: string,
-  name: string = "custom",
+  name   : string = "custom",
 ): Schema<TValue, TValue> {
   return makeSchema(
     (value, path) =>

package/schema.js

@@ -94,14 +94,14 @@ export type Description =
   | {| readonly kind: "map", readonly key: Description, readonly value: Description |}
   | {| readonly kind: "set", readonly item: Description |}
   | {|
-      readonly kind: "object",
-      readonly entries: $ReadOnlyArray<[string, Description]>,
+      readonly kind       : "object",
+      readonly entries    : $ReadOnlyArray<[string, Description]>,
       readonly unknownKeys: "strip" | "reject" | "keep",
     |}
   | {| readonly kind: "union", readonly options: $ReadOnlyArray<Description> |}
   | {|
-      readonly kind: "variant",
-      readonly key: string,
+      readonly kind    : "variant",
+      readonly key     : string,
       readonly branches: $ReadOnlyArray<[string, Description]>,
     |}
   | {| readonly kind: "intersect", readonly parts: $ReadOnlyArray<Description> |}
@@ -113,8 +113,8 @@ export type Description =
   | {| readonly kind: "lazy", readonly id: symbol, readonly inner: () => Description |}
   | {| readonly kind: "transformed", readonly inner: Description |}
   | {|
-      readonly kind: "constrained",
-      readonly inner: Description,
+      readonly kind      : "constrained",
+      readonly inner     : Description,
       readonly constraint: Constraint,
     |};
 
@@ -141,9 +141,9 @@ export type Constraint =
   | {| readonly kind: "opaque", readonly label: string |};
 
 type SchemaKernel<out T> = {|
-  readonly parse: null | ((mixed, PathBuffer) => Result<T>),
+  readonly parse     : null | ((mixed, PathBuffer) => Result<T>),
   readonly parseAsync: null | ((mixed, PathBuffer) => Promise<Result<T>>),
-  readonly describe: () => Description,
+  readonly describe  : () => Description,
 |};
 
 /**
@@ -157,8 +157,8 @@ type SchemaKernel<out T> = {|
  * passed where `Schema<mixed, mixed>` is wanted.
  */
 type SchemaCarrier<out TOutput, out TInput> = {|
-  readonly __kind: "Schema",
-  readonly __input: () => TInput,
+  readonly __kind  : "Schema",
+  readonly __input : () => TInput,
   readonly __kernel: SchemaKernel<TOutput>,
 |};
 
@@ -201,12 +201,12 @@ const phantomInput = (): empty => {
 
 /** Mint a synchronous schema. The only way a `Schema` comes into existence. */
 export function makeSchema<TOutput, TInput>(
-  parse: (mixed, PathBuffer) => Result<TOutput>,
+  parse      : (mixed, PathBuffer) => Result<TOutput>,
   description: () => Description,
 ): Schema<TOutput, TInput> {
   return {
-    __kind: "Schema",
-    __input: phantomInput,
+    __kind  : "Schema",
+    __input : phantomInput,
     __kernel: { parse, parseAsync: null, describe: description },
   };
 }
@@ -218,12 +218,12 @@ export function makeSchema<TOutput, TInput>(
  * reads to decide it is asynchronous too.
  */
 export function makeAsyncSchema<TOutput, TInput>(
-  parseAsync: (mixed, PathBuffer) => Promise<Result<TOutput>>,
+  parseAsync : (mixed, PathBuffer) => Promise<Result<TOutput>>,
   description: () => Description,
 ): Schema<TOutput, TInput> {
   return {
-    __kind: "Schema",
-    __input: phantomInput,
+    __kind  : "Schema",
+    __input : phantomInput,
     __kernel: { parse: null, parseAsync, describe: description },
   };
 }
@@ -257,9 +257,9 @@ export function run<T>(schema: Schema<T, mixed>, value: mixed, path: PathBuffer)
  */
 export function runAt<T>(
   schema: Schema<T, mixed>,
-  value: mixed,
-  path: PathBuffer,
-  key: string,
+  value : mixed,
+  path  : PathBuffer,
+  key   : string,
 ): Result<T> {
   path.push(key);
   const result = run(schema, value, path);
@@ -270,8 +270,8 @@ export function runAt<T>(
 /** Run `schema`, awaiting it if it is asynchronous and calling it if it is not. */
 export function runAsync<T>(
   schema: Schema<T, mixed>,
-  value: mixed,
-  path: PathBuffer,
+  value : mixed,
+  path  : PathBuffer,
 ): Promise<Result<T>> {
   const kernel = schema.__kernel;
   const parseAsync = kernel.parseAsync;
@@ -290,9 +290,9 @@ export function runAsync<T>(
  */
 export function runUnder<T>(
   schema: Schema<T, mixed>,
-  value: mixed,
-  path: PathBuffer,
-  keys: Path,
+  value : mixed,
+  path  : PathBuffer,
+  keys  : Path,
 ): Result<T> {
   for (const key of keys) {
     path.push(key);
@@ -307,18 +307,18 @@ export function runUnder<T>(
 /** Run `schema` deeper, on a path of its own. See the module docs. */
 export function runAtAsync<T>(
   schema: Schema<T, mixed>,
-  value: mixed,
-  path: PathBuffer,
-  keys: Path,
+  value : mixed,
+  path  : PathBuffer,
+  keys  : Path,
 ): Promise<Result<T>> {
   return runAsync(schema, value, path.concat(keys));
 }
 
 /** One child of a composite, for [`collectAsync`]. */
 export type Job = {|
-  readonly keys: Path,
+  readonly keys  : Path,
   readonly schema: Schema<mixed, mixed>,
-  readonly value: mixed,
+  readonly value : mixed,
 |};
 
 /** Every child's outcome, in the order the jobs were given. */
@@ -350,7 +350,7 @@ export async function collectAsync(
   let issues: null | Array<Issue> = null;
   for (const result of results) {
     match (result) {
-      {ok: true, value: const value} => {
+      {ok: true, value: const value}   => {
         values.push(value);
       }
       {ok: false, issues: const found} => {
@@ -383,6 +383,6 @@ export function mergeIssues(issues: Array<Issue>, result: Result<mixed>): void {
         issues.push(entry);
       }
     }
-    _ => {}
+    _                                => {}
   }
 }

package/union.js

@@ -48,7 +48,7 @@ import {
 
 function buildUnion<TOutput, TInput>(options: Options): Schema<TOutput, TInput> {
   const description = (): Description => ({
-    kind: "union",
+    kind   : "union",
     options: options.map((option) => describe(option)),
   });
 
@@ -152,7 +152,7 @@ function buildVariant<TOutput, TInput>(key: string, branches: Shape): Schema<TOu
  * the control that chooses it.
  */
 export function variant<TBranches extends Shape>(
-  key: string,
+  key     : string,
   branches: TBranches,
 ): Schema<InferOutput<TBranches[keyof TBranches]>, InferInput<TBranches[keyof TBranches]>> {
   return buildVariant(key, branches);
@@ -176,18 +176,18 @@ export function variant<TBranches extends Shape>(
  * string and pretend the result satisfies both.
  */
 export function intersect<TLeftOut, TLeftIn, TRightOut, TRightIn>(
-  left: Schema<TLeftOut, TLeftIn>,
+  left : Schema<TLeftOut, TLeftIn>,
   right: Schema<TRightOut, TRightIn>,
 ): Schema<TLeftOut & TRightOut, TLeftIn & TRightIn> {
   const description = (): Description => ({
-    kind: "intersect",
+    kind : "intersect",
     parts: [describe(left), describe(right)],
   });
 
   function combine(
-    first: Result<TLeftOut>,
+    first : Result<TLeftOut>,
     second: Result<TRightOut>,
-    path: Array<string>,
+    path  : Array<string>,
   ): Result<TLeftOut & TRightOut> {
     if (!first.ok || !second.ok) {
       const issues: Array<Issue> = [];