@@ -1,10 +1,11 @@

+/* eslint-disable */

 window.devtoolsFormatters = [

     {

         header(obj, config) {

             if (config && config.genfunFormatter) {

                 return ["div", {}, config.key];

-            } else if (! (obj.gf || obj instanceof GenericFunction) ) {

+            } else if (!(obj.gf || obj instanceof GenericFunction)) {

                 return null;

             } else if (obj.gf) {

                 const args = obj.gf.lambda_list.join(', ');

@@ -12,7 +13,7 @@ window.devtoolsFormatters = [

                 return [

                     'div', {},

                     `GenericFunction lambda: ${obj.gf.name}(${args}) `

-                        + `[${method_count} methods]`

+                    + `[${method_count} methods]`

                 ];

             } else {

                 const args = obj.lambda_list.join(', ');

@@ -1,10 +1,10 @@

-export function NoNextMethodError() {}

+export function NoNextMethodError() { }

 NoNextMethodError.prototype = Object.create(Error);

-export function NoApplicableMethodError() {}

+export function NoApplicableMethodError() { }

 NoApplicableMethodError.prototype = Object.create(Error);

-export function NoPrimaryMethodError() {}

+export function NoPrimaryMethodError() { }

 NoPrimaryMethodError.prototype = Object.create(NoApplicableMethodError);

 const before_qualifier = Symbol.for('before');

@@ -33,19 +33,19 @@ let genfun_prototype = {

     },

     get fn() {

         const gf = this;

-        const lambda = (function() {

+        const lambda = (function () {

             return apply_generic_function(gf, [].slice.call(arguments));

         }).bind(gf);

         return Object.defineProperties(lambda, {

-            'name': {value: gf.name},

-            'lambda_list': {value: gf.lambda_list},

-            'gf': {value: gf},

+            'name': { value: gf.name },

+            'lambda_list': { value: gf.lambda_list },

+            'gf': { value: gf },

         });

     }

 };

 function GenericFunction(name, lambda_list) {

-    if (! (this instanceof GenericFunction) ) {

+    if (!(this instanceof GenericFunction)) {

         return new GenericFunction(...arguments);

     }

@@ -72,7 +72,7 @@ export function defgeneric(name, ...argument_names) {

 export function StandardMethod(

     lambda_list, qualifiers, specializers, body

 ) {

-    if (! (this instanceof StandardMethod) ) {

+    if (!(this instanceof StandardMethod)) {

         return new StandardMethod(...arguments);

     }

@@ -139,7 +139,7 @@ export function sub_specializer_p(c1, c2) {

 const idS = Symbol.for('id');

 Object.prototype[idS] = function () { return this };

-export function Specializer() {}

+export function Specializer() { }

 Specializer.prototype = {

     matches(_obj) { return false; },

     super_of(_obj) { return false; },

@@ -153,17 +153,17 @@ function isSuperset(superset, subset) {

 }

 const matchShape = defgeneric("matchShape", "shape", "value")

-      .primary([Array], ([name, dflt], v) => dflt!==undefined && v[name] === dflt)

-      .primary([String], (name, v) => v[name] !== undefined)

-      .fn;

+    .primary([Array], ([name, dflt], v) => dflt !== undefined && v[name] === dflt)

+    .primary([String], (name, v) => v[name] !== undefined)

+    .fn;

 export const extractKey = defgeneric("extractKey", "key")

-      .primary([Array], ([name, _]) => name)

-      .primary([String], (name) => name)

-      .fn;

+    .primary([Array], ([name, _]) => name)

+    .primary([String], (name) => name)

+    .fn;

 export function Shape(...keys) {

-    if (! (this instanceof Shape) ) {

+    if (!(this instanceof Shape)) {

         return new Shape(...keys);

     }

     this.keys = new Set(keys);

@@ -221,15 +221,15 @@ export function matches_specializer(obj, specializer) {

 function compute_applicable_methods_using_classes(gf, required_classes) {

     const applicable_methods = gf.methods.filter(

         method => method.specializers.every((specializer, idx) => matches_specializer(required_classes[idx], specializer))

-        

+

     );

-    applicable_methods.sort((a,b) => {

+    applicable_methods.sort((a, b) => {

         let result = 0;

-        if (method_more_specific_p(a,b)) {

+        if (method_more_specific_p(a, b)) {

             result = 1;

         }

-        if (method_more_specific_p(b,a)) {

+        if (method_more_specific_p(b, a)) {

             result = -1;

         }

@@ -271,13 +271,13 @@ function arr_eq(a1, a2) {

 // }

 const primary_method_p =

-      method => method instanceof WrappedMethod || method.qualifiers.length === 0;

+    method => method instanceof WrappedMethod || method.qualifiers.length === 0;

 const before_method_p =

-      method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [before_qualifier]);

+    method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [before_qualifier]);

 const after_method_p =

-      method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [after_qualifier]);

+    method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [after_qualifier]);

 const around_method_p =

-      method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [around_qualifier]);

+    method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [around_qualifier]);

 function WrappedMethod(continuation) {

     this.continuation = continuation;

@@ -291,7 +291,7 @@ function apply_methods(gf, args, applicable_methods) {

     afters.reverse();

     const main_call = Object.defineProperty(

-        function() {

+        function () {

             if (primaries.length === 0) {

                 throw new NoPrimaryMethodError(`No primary method for ${gf.name}`);

             }

@@ -308,7 +308,7 @@ function apply_methods(gf, args, applicable_methods) {

                 }

             }

         },

-        'name', {value: `main_call_${gf.name}`}, 

+        'name', { value: `main_call_${gf.name}` },

     );

     if (arounds.length === 0) {

@@ -14,21 +14,21 @@ describe('matches_specializer', () => {

         expect(uut.matches_specializer([], Object)).toBeTruthy();

         expect(uut.matches_specializer([], Number)).toBeFalsy();

-        function Foo() {}

+        function Foo() { }

         Foo.prototype = Object.create(null);

         const inst = new Foo();

         expect(uut.matches_specializer(inst, Foo)).toBeTruthy();

         expect(uut.matches_specializer(inst, Object)).toBeFalsy();

-        expect(uut.matches_specializer({a:1}, uut.Shape('a'))).toBeTruthy();

-        expect(uut.matches_specializer({a:1, b:2}, uut.Shape('a'))).toBeTruthy();

-        expect(uut.matches_specializer({b:2}, uut.Shape('a'))).toBeFalsy();

+        expect(uut.matches_specializer({ a: 1 }, uut.Shape('a'))).toBeTruthy();

+        expect(uut.matches_specializer({ a: 1, b: 2 }, uut.Shape('a'))).toBeTruthy();

+        expect(uut.matches_specializer({ b: 2 }, uut.Shape('a'))).toBeFalsy();

-        expect(uut.matches_specializer({a:1, b:2, c:3}, uut.Shape('a', 'b', 'c'))).toBeTruthy();

-        expect(uut.matches_specializer({a:1, b:2, c:3, d:4}, uut.Shape('a', 'b', 'c'))).toBeTruthy();

-        expect(uut.matches_specializer({a:1, c:3}, uut.Shape('a', 'b', 'c'))).toBeFalsy();

-        expect(uut.matches_specializer({c:3}, uut.Shape('a', 'b', 'c'))).toBeFalsy();

-        expect(uut.matches_specializer({d:3}, uut.Shape('a', 'b', 'c'))).toBeFalsy();

+        expect(uut.matches_specializer({ a: 1, b: 2, c: 3 }, uut.Shape('a', 'b', 'c'))).toBeTruthy();

+        expect(uut.matches_specializer({ a: 1, b: 2, c: 3, d: 4 }, uut.Shape('a', 'b', 'c'))).toBeTruthy();

+        expect(uut.matches_specializer({ a: 1, c: 3 }, uut.Shape('a', 'b', 'c'))).toBeFalsy();

+        expect(uut.matches_specializer({ c: 3 }, uut.Shape('a', 'b', 'c'))).toBeFalsy();

+        expect(uut.matches_specializer({ d: 3 }, uut.Shape('a', 'b', 'c'))).toBeFalsy();

     });

     test('null behavior', () => {

@@ -70,7 +70,7 @@ describe('defgeneric', () => {

         expect(

             uut.defgeneric("testing1", "a", "b")

                 .primary([Object, Object], (_, __) => 1)

-                .fn(1,2)

+                .fn(1, 2)

         ).toEqual(1);

         try {

@@ -85,14 +85,14 @@ describe('defgeneric', () => {

         expect(

             uut.defgeneric("testing1", "a", "b")

                 .primary([Number, Number], (_, __) => 1)

-                .fn(1,2)

+                .fn(1, 2)

         ).toEqual(1);

         expect(

             uut.defgeneric("testing1", "a", "b")

                 .primary([Number, Number], (_, __) => 2)

                 .primary([String, String], (_, __) => 1)

-                .fn("1","2")

+                .fn("1", "2")

         ).toEqual(1);

         let firstCounts = 0;

@@ -100,7 +100,7 @@ describe('defgeneric', () => {

             uut.defgeneric("testing1", "a", "b")

                 .primary([Number, Number], (_, __) => firstCounts += 1)

                 .primary([String, String], (_, __) => firstCounts += 1)

-                .fn("1","2")

+                .fn("1", "2")

         ).toEqual(1);

         expect(firstCounts).toEqual(1);

@@ -109,7 +109,7 @@ describe('defgeneric', () => {

             uut.defgeneric("testing1", "a", "b")

                 .primary([Object, Object], (_, __) => secondCounts += 1)

                 .primary([String, String], (_, __) => secondCounts += 1)

-                .fn("1","2")

+                .fn("1", "2")

         ).toEqual(1);

         expect(secondCounts).toEqual(1);

@@ -119,7 +119,7 @@ describe('defgeneric', () => {

                 .before([Object, Object], (_, __) => thirdCounts += 1)

                 .primary([String, String], (_, __) => 'hi')

                 .after([Object, String], (_, __) => thirdCounts += 1)

-                .fn("1","2")

+                .fn("1", "2")

         ).toEqual('hi');

         expect(thirdCounts).toEqual(2);

@@ -189,19 +189,19 @@ describe('defgeneric', () => {

                 })

                 .fn("foobar")

         ).toEqual(1);

-        

+

         expect(

             uut.defgeneric("foobar", "a", "b")

-                .primary ([String, String], function (a,b) {

+                .primary([String, String], function (a, b) {

                     return `1${this.call_next_method()}`;

                 })

-                .primary ([Object, String], function (a,b) {

+                .primary([Object, String], function (a, b) {

                     return `3${this.call_next_method()}`;

                 })

-                .primary ([String, Object], function (a,b) {

+                .primary([String, Object], function (a, b) {

                     return `2${this.call_next_method()}`;

                 })

-                .primary ([Object, Object], function (a,b) {

+                .primary([Object, Object], function (a, b) {

                     return `4`;

                 }).fn("a", "b")

         ).toEqual("1234");

@@ -223,33 +223,33 @@ describe('defgeneric', () => {

 describe('custom specializers', () => {

     test('Shape works', () => {

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

-               .primary([Object], _ => null)

-               .fn({a:1,b:2}))

+            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)

+            .primary([Object], _ => null)

+            .fn({ a: 1, b: 2 }))

             .toEqual(3);

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

-               .primary([Object], _ => null)

-               .fn({a:1,b:2,c:3}))

+            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)

+            .primary([Object], _ => null)

+            .fn({ a: 1, b: 2, c: 3 }))

             .toEqual(3);

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

-               .primary([Object], _ => null)

-               .fn({a:1}))

+            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)

+            .primary([Object], _ => null)

+            .fn({ a: 1 }))

             .toEqual(null);

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape(['a', 1], 'b')], ({a,b}) => a+b)

-               .primary([Object], _ => null)

-               .fn({a:1, b: 3}))

+            .primary([uut.Shape(['a', 1], 'b')], ({ a, b }) => a + b)

+            .primary([Object], _ => null)

+            .fn({ a: 1, b: 3 }))

             .toEqual(4);

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape(['a', null], 'b')], ({a,b}) => b)

-               .primary([Object], _ => null)

-               .fn({a:null, b: 3}))

+            .primary([uut.Shape(['a', null], 'b')], ({ a, b }) => b)

+            .primary([Object], _ => null)

+            .fn({ a: null, b: 3 }))

             .toEqual(3);

         expect(uut.defgeneric("foobar", "a")

@@ -259,34 +259,34 @@ describe('custom specializers', () => {

             .toEqual(null); //undefined is not a permissible default: treated as if the key is missing

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape(['a', 1], 'b')], ({a,b}) => a+b)

-               .primary([Object], _ => null)

-               .fn({a:2, b: 3}))

+            .primary([uut.Shape(['a', 1], 'b')], ({ a, b }) => a + b)

+            .primary([Object], _ => null)

+            .fn({ a: 2, b: 3 }))

             .toEqual(null);

     });

     test('Shape, prototype precedence', () => {

         expect(uut.defgeneric("foobar4", "a")

-               .primary([uut.Shape('a')], ({a}) => a)

-               .primary([uut.Shape('a', 'b')], ({a,b}) => {return a+b})

-               .primary([Object], _ => null).fn({a:1,b:3}))

+            .primary([uut.Shape('a')], ({ a }) => a)

+            .primary([uut.Shape('a', 'b')], ({ a, b }) => { return a + b })

+            .primary([Object], _ => null).fn({ a: 1, b: 3 }))

             .toEqual(4);

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

-               .primary([uut.Shape('b')], ({b}) => b)

-               .primary([Object], _ => null)

-               .fn({a:1,b:2}))

+            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)

+            .primary([uut.Shape('b')], ({ b }) => b)

+            .primary([Object], _ => null)

+            .fn({ a: 1, b: 2 }))

             .toEqual(3);

-        const Foo = function () {}

-        Foo.prototype = {a: true, b: null};

+        const Foo = function () { }

+        Foo.prototype = { a: true, b: null };

         expect(uut.defgeneric("foobar", "a")

-               .primary([uut.Shape('a')], function ({a}) { return `a${this.call_next_method()}`; })

-               .primary([uut.Shape('a', 'b', 'c')], function ({a,b,c}) { return `c${this.call_next_method()}`; })

-               .primary([uut.Shape('a', 'b')], function ({a,b}) { return `b${this.call_next_method()}`; })

-               .primary([Object], _ => 'd')

-               .fn(Object.assign(new Foo(), {c: 3})))

+            .primary([uut.Shape('a')], function ({ a }) { return `a${this.call_next_method()}`; })

+            .primary([uut.Shape('a', 'b', 'c')], function ({ a, b, c }) { return `c${this.call_next_method()}`; })

+            .primary([uut.Shape('a', 'b')], function ({ a, b }) { return `b${this.call_next_method()}`; })

+            .primary([Object], _ => 'd')

+            .fn(Object.assign(new Foo(), { c: 3 })))

             .toEqual('cbad');

     });

 });