@es-joy/jsoe 0.16.0 → 0.17.0

package/vendor/zodex/dist/esm/ui.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { SzInfer } from "./infer.js";
+import { SzType } from "./types.js";
+type ShapeValueProps<Value> = {
+    value: Value;
+    onChange: (_value: Value) => void;
+};
+type ShapeProps<T extends SzType> = {
+    shape: T;
+} & ShapeValueProps<SzInfer<T>>;
+type MappedShapeControl<T extends SzType> = {
+    [Type in T["type"]]: React.FC<ShapeProps<Extract<T, {
+        type: Type;
+    }>>>;
+};
+export declare function mapTypesToViews<T extends SzType>(controls: MappedShapeControl<T>): <I = SzInfer<T>>({ shape, value, onChange, }: {
+    shape: T;
+    value: I;
+    onChange: (_value: I) => void;
+}) => React.FunctionComponentElement<ShapeProps<Extract<T, {
+    type: T["type"];
+}>>>;
+export {};

package/vendor/zodex/dist/esm/ui.js

@@ -0,0 +1,10 @@
+import React from "react";
+export function mapTypesToViews(controls) {
+    return function ShapeControl({ shape, value, onChange, }) {
+        return React.createElement(controls[shape.type], {
+            shape,
+            value,
+            onChange,
+        });
+    };
+}

package/vendor/zodex/dist/esm/zerialize.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { SzOptional, SzNullable, SzDefault, SzLiteral, SzArray, SzObject, SzUnion, SzDiscriminatedUnion, SzIntersection, SzTuple, SzRecord, SzMap, SzSet, SzFunction, SzEnum, SzPromise, SzEffect, SzCatch, SzReadonly, SzType, SzUnknown, SzRef } from "./types.js";
+import { ZodTypes, ZTypeName } from "./zod-types.js";
+export declare const PRIMITIVES: {
+    readonly ZodString: "string";
+    readonly ZodNumber: "number";
+    readonly ZodBoolean: "boolean";
+    readonly ZodNaN: "nan";
+    readonly ZodBigInt: "bigInt";
+    readonly ZodDate: "date";
+    readonly ZodUndefined: "undefined";
+    readonly ZodNull: "null";
+    readonly ZodAny: "any";
+    readonly ZodUnknown: "unknown";
+    readonly ZodNever: "never";
+    readonly ZodVoid: "void";
+    readonly ZodSymbol: "symbol";
+};
+export type PrimitiveMap = typeof PRIMITIVES;
+type IsZodPrimitive<T extends ZodTypes> = ZTypeName<T> extends keyof PrimitiveMap ? any : never;
+export type Zerialize<T extends ZodTypes> = T extends z.ZodOptional<infer I> ? Zerialize<I> & SzOptional : T extends z.ZodNullable<infer I> ? Zerialize<I> & SzNullable : T extends z.ZodDefault<infer I> ? Zerialize<I> & SzDefault<I["_type"]> : T extends z.ZodReadonly<infer I> ? Zerialize<I> & SzReadonly : T extends IsZodPrimitive<T> ? {
+    type: PrimitiveMap[ZTypeName<T>];
+} : T extends z.ZodLiteral<infer T> ? SzLiteral<T> : T extends z.ZodTuple<infer Items> ? {
+    [Index in keyof Items]: Zerialize<Items[Index]>;
+} extends infer SzItems extends [SzType, ...SzType[]] | [] ? SzTuple<SzItems> : SzType : T extends z.ZodSet<infer T> ? SzSet<Zerialize<T>> : T extends z.ZodArray<infer T> ? SzArray<Zerialize<T>> : T extends z.ZodObject<infer Properties> ? SzObject<{
+    [Property in keyof Properties]: Zerialize<Properties[Property]>;
+}> : T extends z.ZodRecord<infer Key, infer Value> ? SzRecord<Zerialize<Key>, Zerialize<Value>> : T extends z.ZodMap<infer Key, infer Value> ? SzMap<Zerialize<Key>, Zerialize<Value>> : T extends z.ZodEnum<infer Values> ? SzEnum<Values> : T extends z.ZodNativeEnum<infer _Values> ? SzUnknown : T extends z.ZodUnion<infer Options> ? {
+    [Index in keyof Options]: Zerialize<Options[Index]>;
+} extends infer SzOptions extends [
+    SzType,
+    ...SzType[]
+] ? SzUnion<SzOptions> : SzType : T extends z.ZodDiscriminatedUnion<infer Discriminator, infer Options> ? SzDiscriminatedUnion<Discriminator, {
+    [Index in keyof Options]: Zerialize<Options[Index]>;
+}> : T extends z.ZodIntersection<infer L, infer R> ? SzIntersection<Zerialize<L>, Zerialize<R>> : T extends z.ZodFunction<infer Args, infer Return> ? Zerialize<Args> extends infer SzArgs extends SzTuple ? SzFunction<SzArgs, Zerialize<Return>> : SzType : T extends z.ZodPromise<infer Value> ? SzPromise<Zerialize<Value>> : T extends z.ZodCatch<infer T> ? SzCatch<Zerialize<T>> : T extends z.ZodEffects<infer T> ? SzEffect<Zerialize<T>> : T extends z.ZodLazy<infer T> ? Zerialize<T> : T extends z.ZodBranded<infer T, infer _Brand> ? Zerialize<T> : T extends z.ZodPipeline<infer _In, infer Out> ? Zerialize<Out> : T extends z.ZodCatch<infer Inner> ? Zerialize<Inner> : SzType;
+type ZerializerOptions = {
+    superRefinements?: {
+        [key: string]: (value: any, ctx: z.RefinementCtx) => Promise<void> | void;
+    };
+    transforms?: {
+        [key: string]: (value: any, ctx: z.RefinementCtx) => Promise<unknown> | unknown;
+    };
+    preprocesses?: {
+        [key: string]: (value: any, ctx: z.RefinementCtx) => unknown;
+    };
+    currentPath: string[];
+    seenObjects: WeakMap<z.ZodTypeDef, string>;
+};
+export declare function zerializeRefs<T extends ZodTypes>(schema: T, opts: ZerializerOptions, wrapReferences?: boolean): Zerialize<T> | SzRef;
+export declare function zerialize<T extends ZodTypes>(schema: T, opts?: Partial<ZerializerOptions>): Zerialize<T>;
+export {};

package/vendor/zodex/dist/esm/zerialize.js

@@ -0,0 +1,417 @@
+import { z } from "zod";
+import { STRING_KINDS, } from "./types.js";
+export const PRIMITIVES = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBoolean: "boolean",
+    ZodNaN: "nan",
+    ZodBigInt: "bigInt",
+    ZodDate: "date",
+    ZodUndefined: "undefined",
+    ZodNull: "null",
+    ZodAny: "any",
+    ZodUnknown: "unknown",
+    ZodNever: "never",
+    ZodVoid: "void",
+    ZodSymbol: "symbol",
+};
+const s = zerializeRefs;
+const zerializers = {
+    ZodOptional: (def, opts) => ({
+        ...s(def.innerType, opts, true),
+        isOptional: true,
+    }),
+    ZodNullable: (def, opts) => ({
+        ...s(def.innerType, opts, true),
+        isNullable: true,
+    }),
+    ZodDefault: (def, opts) => ({
+        ...s(def.innerType, opts, true),
+        defaultValue: def.innerType._def.typeName === "ZodBigInt"
+            ? String(def.defaultValue())
+            : def.innerType._def.typeName === "ZodDate"
+                ? def.defaultValue().getTime()
+                : def.defaultValue(),
+    }),
+    ZodNumber: (def) => {
+        const checks = def.checks.reduce((o, check) => ({
+            ...o,
+            ...(check.kind == "min"
+                ? {
+                    min: check.value,
+                    ...(check.inclusive ? { minInclusive: true } : {}),
+                }
+                : check.kind == "max"
+                    ? {
+                        max: check.value,
+                        ...(check.inclusive ? { maxInclusive: true } : {}),
+                    }
+                    : check.kind == "multipleOf"
+                        ? { multipleOf: check.value }
+                        : check.kind == "int"
+                            ? { int: true }
+                            : check.kind == "finite"
+                                ? {
+                                    finite: true,
+                                    /* c8 ignore next 2 -- Guard */
+                                }
+                                : {}),
+        }), {});
+        return Object.assign({ type: "number", ...checks }, def.coerce ? { coerce: true } : {});
+    },
+    ZodString: (def) => {
+        const checks = def.checks.reduce((o, check) => ({
+            ...o,
+            ...(check.kind == "min"
+                ? { min: check.value }
+                : check.kind == "max"
+                    ? { max: check.value }
+                    : check.kind == "length"
+                        ? { length: check.value }
+                        : check.kind == "toLowerCase"
+                            ? { toLowerCase: true }
+                            : check.kind == "toUpperCase"
+                                ? { toUpperCase: true }
+                                : check.kind == "trim"
+                                    ? { trim: true }
+                                    : check.kind == "startsWith"
+                                        ? { startsWith: check.value }
+                                        : check.kind == "endsWith"
+                                            ? { endsWith: check.value }
+                                            : check.kind == "includes"
+                                                ? { includes: check.value, position: check.position }
+                                                : check.kind == "regex"
+                                                    ? {
+                                                        regex: check.regex.source,
+                                                        ...(check.regex.flags
+                                                            ? { flags: check.regex.flags }
+                                                            : {}),
+                                                    }
+                                                    : check.kind == "ip"
+                                                        ? { kind: "ip", version: check.version }
+                                                        : check.kind == "time"
+                                                            ? {
+                                                                kind: "time",
+                                                                ...(typeof check.precision === "number"
+                                                                    ? { precision: check.precision }
+                                                                    : {}),
+                                                            }
+                                                            : check.kind == "datetime"
+                                                                ? {
+                                                                    kind: "datetime",
+                                                                    ...(check.offset
+                                                                        ? { offset: check.offset }
+                                                                        : {}),
+                                                                    ...("local" in check && check.local
+                                                                        ? { local: check.local }
+                                                                        : {}),
+                                                                    ...(typeof check.precision === "number"
+                                                                        ? { precision: check.precision }
+                                                                        : {}),
+                                                                }
+                                                                : STRING_KINDS.has(check.kind)
+                                                                    ? {
+                                                                        kind: check.kind,
+                                                                        /* c8 ignore next 2 -- Guard */
+                                                                    }
+                                                                    : {}),
+        }), {});
+        return Object.assign({ type: "string", ...checks }, def.coerce ? { coerce: true } : {});
+    },
+    ZodBoolean: (def) => Object.assign({ type: "boolean" }, def.coerce ? { coerce: true } : {}),
+    ZodNaN: () => ({ type: "nan" }),
+    ZodSymbol: (def) => ({ type: "symbol" }),
+    ZodBigInt: (def) => {
+        const checks = def.checks.reduce((o, check) => ({
+            ...o,
+            ...(check.kind == "min"
+                ? {
+                    min: String(check.value),
+                    ...(check.inclusive ? { minInclusive: true } : {}),
+                }
+                : check.kind == "max"
+                    ? {
+                        max: String(check.value),
+                        ...(check.inclusive ? { maxInclusive: true } : {}),
+                    }
+                    : check.kind == "multipleOf"
+                        ? {
+                            multipleOf: String(check.value),
+                            /* c8 ignore next 2 -- Guard */
+                        }
+                        : {}),
+        }), {});
+        return Object.assign({ type: "bigInt", ...checks }, def.coerce ? { coerce: true } : {});
+    },
+    ZodDate: (def) => {
+        const checks = def.checks.reduce((o, check) => ({
+            ...o,
+            ...(check.kind == "min"
+                ? { min: check.value }
+                : check.kind == "max"
+                    ? {
+                        max: check.value,
+                        /* c8 ignore next 2 -- Guard */
+                    }
+                    : {}),
+        }), {});
+        return Object.assign({ type: "date", ...checks }, def.coerce ? { coerce: true } : {});
+    },
+    ZodUndefined: () => ({ type: "undefined" }),
+    ZodNull: () => ({ type: "null" }),
+    ZodAny: () => ({ type: "any" }),
+    ZodUnknown: () => ({ type: "unknown" }),
+    ZodNever: () => ({ type: "never" }),
+    ZodVoid: () => ({ type: "void" }),
+    ZodLiteral: (def) => ({ type: "literal", value: def.value }),
+    ZodTuple: (def, opts) => ({
+        type: "tuple",
+        items: def.items.map((item, idx) => {
+            const result = s(item, {
+                ...opts,
+                currentPath: [...opts.currentPath, "items", String(idx)],
+            });
+            return result;
+        }),
+        ...(def.rest
+            ? {
+                rest: s(def.rest, {
+                    ...opts,
+                    currentPath: [...opts.currentPath, "rest"],
+                }),
+            }
+            : {}),
+    }),
+    ZodSet: (def, opts) => ({
+        type: "set",
+        value: s(def.valueType, {
+            ...opts,
+            currentPath: [...opts.currentPath, "value"],
+        }),
+        ...(def.minSize === null ? {} : { minSize: def.minSize.value }),
+        ...(def.maxSize === null ? {} : { maxSize: def.maxSize.value }),
+    }),
+    ZodArray: (def, opts) => ({
+        type: "array",
+        element: s(def.type, {
+            ...opts,
+            currentPath: [...opts.currentPath, "element"],
+        }),
+        ...(def.exactLength === null
+            ? {}
+            : {
+                minLength: def.exactLength.value,
+                maxLength: def.exactLength.value,
+            }),
+        ...(def.minLength === null ? {} : { minLength: def.minLength.value }),
+        ...(def.maxLength === null ? {} : { maxLength: def.maxLength.value }),
+    }),
+    ZodObject: (def, opts) => ({
+        type: "object",
+        ...(def.catchall._def.typeName === "ZodNever"
+            ? {}
+            : {
+                catchall: s(def.catchall, {
+                    ...opts,
+                    currentPath: [...opts.currentPath, "catchall"],
+                }),
+            }),
+        ...(def.unknownKeys === "strip"
+            ? {}
+            : {
+                unknownKeys: def.unknownKeys,
+            }),
+        properties: Object.fromEntries(Object.entries(def.shape()).map(([key, schema]) => [
+            key,
+            s(schema, {
+                ...opts,
+                currentPath: [...opts.currentPath, "properties", key],
+            }),
+        ])),
+    }),
+    ZodRecord: (def, opts) => ({
+        type: "record",
+        key: s(def.keyType, {
+            ...opts,
+            currentPath: [...opts.currentPath, "key"],
+        }),
+        value: s(def.valueType, {
+            ...opts,
+            currentPath: [...opts.currentPath, "value"],
+        }),
+    }),
+    ZodMap: (def, opts) => ({
+        type: "map",
+        key: s(def.keyType, {
+            ...opts,
+            currentPath: [...opts.currentPath, "key"],
+        }),
+        value: s(def.valueType, {
+            ...opts,
+            currentPath: [...opts.currentPath, "value"],
+        }),
+    }),
+    ZodEnum: (def) => ({ type: "enum", values: def.values }),
+    ZodNativeEnum: (def, opts) => ({
+        type: "nativeEnum",
+        values: def.values,
+    }),
+    ZodUnion: (def, opts) => ({
+        type: "union",
+        options: def.options.map((opt, idx) => {
+            const result = s(opt, {
+                ...opts,
+                currentPath: [...opts.currentPath, "options", String(idx)],
+            });
+            return result;
+        }),
+    }),
+    ZodDiscriminatedUnion: (def, opts) => ({
+        type: "discriminatedUnion",
+        discriminator: def.discriminator,
+        options: def.options.map((opt, idx) => {
+            const result = s(opt, {
+                ...opts,
+                currentPath: [...opts.currentPath, "options", String(idx)],
+            });
+            return result;
+        }),
+    }),
+    ZodIntersection: (def, opts) => ({
+        type: "intersection",
+        left: s(def.left, {
+            ...opts,
+            currentPath: [...opts.currentPath, "left"],
+        }),
+        right: s(def.right, {
+            ...opts,
+            currentPath: [...opts.currentPath, "right"],
+        }),
+    }),
+    ZodFunction: (def, opts) => ({
+        type: "function",
+        args: s(def.args, {
+            ...opts,
+            currentPath: [...opts.currentPath, "args"],
+        }),
+        returns: s(def.returns, {
+            ...opts,
+            currentPath: [...opts.currentPath, "returns"],
+        }),
+    }),
+    ZodPromise: (def, opts) => ({
+        type: "promise",
+        value: s(def.type, {
+            ...opts,
+            currentPath: [...opts.currentPath, "value"],
+        }),
+    }),
+    ZodLazy: (def, opts) => {
+        const getter = def.getter();
+        return s(getter, opts, getter.isOptional() || getter.isNullable());
+    },
+    ZodEffects: (def, opts) => {
+        if (!("superRefinements" in opts ||
+            "transforms" in opts ||
+            "preprocesses" in opts)) {
+            return s(def.schema, opts);
+        }
+        const effects = [];
+        let lastDef;
+        let d = def;
+        do {
+            lastDef = d;
+            let found;
+            if ("superRefinements" in opts && opts.superRefinements) {
+                for (const [name, refinement] of Object.entries(opts.superRefinements)) {
+                    if (d.effect.type === "refinement" &&
+                        refinement === d.effect.refinement) {
+                        effects.unshift({ type: "refinement", name });
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found && "transforms" in opts && opts.transforms) {
+                for (const [name, transform] of Object.entries(opts.transforms)) {
+                    if (d.effect.type === "transform" &&
+                        transform === d.effect.transform) {
+                        effects.unshift({ type: "transform", name });
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found && "preprocesses" in opts && opts.preprocesses) {
+                for (const [name, preprocess] of Object.entries(opts.preprocesses)) {
+                    if (d.effect.type === "preprocess" &&
+                        preprocess === d.effect.transform) {
+                        effects.unshift({ type: "preprocess", name });
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            d = d.schema._def;
+        } while (d && d.typeName === "ZodEffects");
+        return {
+            type: "effect",
+            effects,
+            inner: s(lastDef.schema, {
+                ...opts,
+                currentPath: [...opts.currentPath, "inner"],
+            }),
+        };
+    },
+    ZodBranded: (def, opts) => s(def.type, opts),
+    ZodPipeline: (def, opts) => s(def.out, opts),
+    ZodCatch: (def, opts) => {
+        const catchValue = def.catchValue({
+            // No errors to report, so just add an empty set
+            get error() {
+                /* c8 ignore next 2 -- Unused */
+                return new z.ZodError([]);
+            },
+            // We don't have any input yet, so just provide `undefined`
+            input: undefined,
+        });
+        return {
+            type: "catch",
+            value: catchValue,
+            innerType: s(def.innerType, opts),
+        };
+    },
+    ZodReadonly: (def, opts) => ({
+        ...s(def.innerType, opts, true),
+        readonly: true,
+    }),
+};
+// Must match the exported Zerialize types
+export function zerializeRefs(schema, opts, wrapReferences) {
+    // export function zerialize(schema: ZodTypes, opts?: Partial<ZerializerOptions> | undefined): unknown {
+    if (opts.seenObjects.has(schema)) {
+        return wrapReferences // && schema._def.typeName !== "ZodOptional"
+            ? {
+                type: "union",
+                options: [{ $ref: opts.seenObjects.get(schema) }],
+            }
+            : { $ref: opts.seenObjects.get(schema) };
+    }
+    const { _def: def } = schema;
+    const objectPath = "#" + (opts.currentPath.length ? "/" + opts.currentPath.join("/") : "");
+    opts.seenObjects.set(schema, objectPath);
+    const zer = zerializers[def.typeName](def, opts);
+    if (typeof def.description === "string") {
+        zer.description = def.description;
+    }
+    return zer;
+}
+export function zerialize(schema, opts = {}) {
+    if (!opts.currentPath) {
+        opts.currentPath = [];
+    }
+    if (!opts.seenObjects) {
+        opts.seenObjects = new WeakMap();
+    }
+    return zerializeRefs(schema, opts);
+}

package/vendor/zodex/dist/esm/zod-types.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+type Modifiers = z.ZodOptional<ZodTypes> | z.ZodNullable<ZodTypes> | z.ZodDefault<ZodTypes> | z.ZodReadonly<ZodTypes>;
+type Primitives = z.ZodString | z.ZodNumber | z.ZodNaN | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodUndefined | z.ZodNull | z.ZodAny | z.ZodUnknown | z.ZodNever | z.ZodVoid | z.ZodSymbol;
+type ListCollections = z.ZodTuple<any, any> | z.ZodSet<ZodTypes> | z.ZodArray<ZodTypes>;
+type KVCollections = z.ZodObject<any> | z.ZodRecord<any, ZodTypes> | z.ZodMap<ZodTypes, ZodTypes>;
+type ADTs = z.ZodUnion<readonly [ZodTypes, ...ZodTypes[]]> | z.ZodDiscriminatedUnion<any, z.ZodObject<{
+    [k: string]: ZodTypes;
+}>[]> | z.ZodIntersection<ZodTypes, ZodTypes> | z.ZodNativeEnum<any> | z.ZodEnum<any>;
+export type ZodTypes = Modifiers | Primitives | ListCollections | KVCollections | ADTs | z.ZodFunction<any, ZodTypes> | z.ZodLazy<ZodTypes> | z.ZodLiteral<any> | z.ZodEffects<any, any> | z.ZodCatch<ZodTypes> | z.ZodPromise<ZodTypes> | z.ZodBranded<ZodTypes, any> | z.ZodPipeline<ZodTypes, ZodTypes>;
+export type ZTypeName<T extends ZodTypes> = T["_def"]["typeName"];
+export {};

package/vendor/zodex/dist/esm/zod-types.js

@@ -0,0 +1 @@
+export {};

package/.eslintignore

@@ -1,13 +0,0 @@
-node_modules
-coverage
-instrumented
-ignore
-src/deepEqual.js
-src/main-pages.js
-vendor
-!.*.js
-
-src/formats/schemaOnly.js
-src/formats/schemaAndArbitrary.js
-typings/**
-dist

package/.eslintrc.cjs

@@ -1,145 +0,0 @@
-'use strict';
-
-module.exports = {
-  extends: ['ash-nazg/sauron-node-overrides', 'plugin:cypress/recommended'],
-  parserOptions: {
-    ecmaVersion: 2022
-  },
-  settings: {
-    jsdoc: {
-      mode: 'typescript'
-    },
-    polyfills: [
-      'AggregateError',
-      'Array.isArray',
-      'Array.filter',
-      'Array.flatMap',
-      'Array.forEach',
-      'Array.from',
-      'Array.includes',
-      'Array.map',
-      'Array.reduce',
-      'Array.some',
-      'ArrayBuffer',
-      'BigInt',
-      'BigInt64Array',
-      'Blob',
-      'btoa',
-      'console',
-      'DataView',
-      'Date.toISOString',
-      'document.body',
-      'document.createDocumentFragment',
-      'document.querySelector',
-      'document.querySelectorAll',
-      'DOMException',
-      'DOMMatrix',
-      'DOMMatrixReadOnly',
-      'DOMPoint',
-      'DOMPointReadOnly',
-      'DOMRect',
-      'DOMRectReadOnly',
-      'Error',
-      'fetch',
-      'File',
-      'FileList',
-      'FileList.item',
-      'FileReader',
-      'history',
-      'IDBKeyRange',
-      'indexedDB',
-      'JSON',
-      'location.hash',
-      'location.href',
-      'location.pathname',
-      'Map',
-      'MediaRecorder',
-      'MutationObserver',
-      'navigator.mediaDevices',
-      'Number.isNaN',
-      'Number.parseFloat',
-      'Number.parseInt',
-      'Object.assign',
-      'Object.hasOwn',
-      'Object.is',
-      'Object.keys',
-      'Object.entries',
-      'Object.values',
-      'Promise',
-      'requestAnimationFrame',
-      'Set',
-      'String.replaceAll',
-      'Symbol',
-      'Symbol.toStringTag',
-      'Uint8Array',
-      'URL',
-      'URLSearchParams',
-      'WeakMap'
-    ],
-    coverage: true
-  },
-  env: {
-    node: false,
-    browser: true
-  },
-  overrides: [
-    {
-      files: '*.md/*.js',
-      rules: {
-        'import/unambiguous': 'off'
-      }
-    },
-    {
-      files: 'cypress/**',
-      rules: {
-        'import/unambiguous': 'off'
-      }
-    }
-  ],
-  rules: {
-    'no-console': 0,
-    'no-shadow': 0,
-    // 'jsdoc/require-jsdoc': ['error', {
-    //   require: {
-    //     ArrowFunctionExpression: true,
-    //     ClassDeclaration: true,
-    //     ClassExpression: true,
-    //     FunctionDeclaration: true,
-    //     FunctionExpression: true,
-    //     MethodDefinition: true
-    //   }
-    // }],
-    quotes: ['error', 'single', {
-      avoidEscape: true, allowTemplateLiterals: true
-    }],
-
-    'jsdoc/require-jsdoc': ['warn', {
-      contexts: [
-        'Program > VariableDeclaration > ' +
-          'VariableDeclarator > ArrowFunctionExpression',
-        'Program > VariableDeclaration > ' +
-          'VariableDeclarator > FunctionExpression',
-        'ExportNamedDeclaration > VariableDeclaration > ' +
-          'VariableDeclarator > ArrowFunctionExpression',
-        'ExportNamedDeclaration > VariableDeclaration > ' +
-          'VariableDeclarator > FunctionExpression',
-        'ExportDefaultDeclaration > ArrowFunctionExpression',
-        'ExportDefaultDeclaration > FunctionExpression',
-
-        'ClassDeclaration',
-        'ClassExpression',
-        'FunctionDeclaration', // Default is true
-        'MethodDefinition'
-      ]
-    }],
-
-    // Disable until find time
-    'prefer-named-capture-group': 0,
-    'eslint-comments/require-description': 0,
-    // Disable until rule improved?
-    'require-atomic-updates': 0,
-    // Disable; waiting on https://github.com/mysticatea/eslint-plugin-node/issues/162
-    'n/no-unpublished-import': 0,
-    'unicorn/no-this-assignment': 0
-  }
-};