formatting

.eslintrc

@@ -3,21 +3,6 @@
   "parserOptions": {
     "sourceType": "module"
   },
-  "rules": {
-    "no-undef": "error",
-    "no-new": "off",
-    "max-len": ["warn", 120],
-    "@typescript-eslint/explicit-member-accessibility": "off",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/interface-name-prefix": "off",
-    "@typescript-eslint/no-empty-interface": "off",
-    "@typescript-eslint/no-parameter-properties": "off",
-    "@typescript-eslint/ban-types": "off",
-    "@typescript-eslint/no-empty-function": "warn",
-    "no-unused-vars": "off",
-    "no-shadow": "off",
-    "indent": ["warn", 2]
-  },
   "env": {
     "es6": true,
     "mocha": true,

rete.config.ts

@@ -1,9 +1,9 @@
 import { ReteOptions } from 'rete-cli'
 
 export default <ReteOptions>{
-    input: 'src/index.ts',
-    name: 'Rete',
-    globals: {
-        crypto: 'crypto'
-    }
+  input: 'src/index.ts',
+  name: 'Rete',
+  globals: {
+    crypto: 'crypto'
+  }
 }

src/index.ts

@@ -4,5 +4,3 @@ export * from './scope'
 export * from './types'
 export * from './utility-types'
 export * from './utils'
-
-console.log('rete')

src/scope.ts

@@ -23,7 +23,7 @@ export class Signal<T> {
 
 export class Scope<Produces, Parents extends unknown[] = []> {
   signal = new Signal<AcceptPartialUnion<Produces | Parents[number]>>()
-  parent?: any//Parents['length'] extends 0 ? undefined : Scope<Parents[0], Tail<Parents>>
+  parent?: any // Parents['length'] extends 0 ? undefined : Scope<Parents[0], Tail<Parents>>
 
   constructor(public name: string) {}
 

src/utility-types.ts

@@ -2,39 +2,38 @@
 
 export type AcceptPartialUnion<T> = T | any
 
-export type Tail<T extends any[]> = ((...args: T) => void) extends (head: any, ...tail: infer U) => any ? U : never;
-
+export type Tail<T extends any[]> = ((...args: T) => void) extends (head: any, ...tail: infer U) => any ? U : never
 
 type UnionToIntersection<U> = (
   U extends never ? never : (arg: U) => never
 ) extends (arg: infer I) => void
   ? I
-  : never;
+  : never
 
 type StrictExcludeInner<T, U> = 0 extends (
     U extends T ? [T] extends [U] ? 0 : never : never
-) ? never : T;
-type StrictExclude<T, U> = T extends unknown ? StrictExcludeInner<T, U> : never;
+) ? never : T
+type StrictExclude<T, U> = T extends unknown ? StrictExcludeInner<T, U> : never
 
 type UnionToTuple<T> = UnionToIntersection<
   T extends never ? never : (t: T) => T
 > extends (_: never) => infer W
   ? [...UnionToTuple<StrictExclude<T, W>>, W]
-  : [];
+  : []
 
-type FilterMatch<T extends any[], V> = T extends [infer Head, ...infer Tail]
+type FilterMatch<T extends any[], V> = T extends [infer Head, ...infer _Tail]
   ? ([Head] extends [V]
-    ? [Head, ...FilterMatch<Tail, V>]
-    : FilterMatch<Tail, V>
+    ? [Head, ...FilterMatch<_Tail, V>]
+    : FilterMatch<_Tail, V>
   ): []
 
 type CanAssignToAnyOf<Provides, Requires> = FilterMatch<UnionToTuple<Provides>, Requires> extends [] ? false : true
 
-type CanAssignEachTupleElemmentToAnyOf<Provides, Requires extends any[]> = Requires extends [infer Head, ...infer Tail]
+type CanAssignEachTupleElemmentToAnyOf<Provides, Requires extends any[]> = Requires extends [infer Head, ...infer _Tail]
     ? CanAssignToAnyOf<Provides, Head> extends true ?
-      (Tail extends []
+      (_Tail extends []
         ? true
-        : CanAssignEachTupleElemmentToAnyOf<Provides, Tail>
+        : CanAssignEachTupleElemmentToAnyOf<Provides, _Tail>
       ): false
     : false
 

src/utils.ts

@@ -1,4 +1,4 @@
-/*global globalThis*/
+/* global globalThis*/
 
 const nodeCrypto = () => import('node:crypto')