anchor.diff:      api.mainModule('dist/elm-app.js', 'client');
   });
   ```
  -explain, link to the doc
  +
  +`Package.describe` says that our package:
  +
  +- is called `elm-app`,
  +- is in version `1.0.0`
  +
  +`Package.onUse` says that our package:
  +
  +- is implemented to be use with Meteor `1.10.2`, 
  +- uses the `modules` package because we will use `import {} from ''`,
  +- will add the `dist/elm-app.css` file in the client when it will be loaded,
  +- have a main js file for this package called `dist/elm-app.js`.
  +
  +If you are using `elm-css` and if you don't need specific css classes in your app, you can remove `api.addFiles('dist/elm-app.css', 'client');` from the `package.js` file.
  +
  +NOTE: For more informations about the Package.js file, see https://docs.meteor.com/api/packagejs.html
   
   === Create the app
   
  -it will ignore changes in this folder, and avoid meteor to reload each time we change stuff in this folder. 
  -
  -into the folder `packages/elm-app/app`
  -run
  -```shell
  -../../../node_modules/.bin/elm init
  -```
  -
  -in `packages/elm-app/app/src`, create your `Main.elm` file
  +We will create our Elm application under the folder `packages/elm-app/app`.
  +To do that, run the following command:
  +
  +```shell
  +#under meteor-elm-app/packages/elm-app/app
  +meteor npm run elm -- init
  +```
  +
  +Validate the creation of the `elm.json` file and we are good 👍.
  +
  +At this step, your folder should be like this:
  +```shell
  +❯ tree -I 'node_modules|.meteor' -a
  +.
  +├── .gitignore
  +├── .meteorignore
  +├── client
  +│   ├── main.css
  +│   ├── main.html
  +│   └── main.ts
  +├── imports
  +│   └── api
  +├── package-lock.json
  +├── package.json
  +├── packages
  +│   └── elm-app
  +│       ├── app
  +│       │   ├── elm.json
  +│       │   └── src
  +│       ├── dist
  +│       └── package.js
  +└── server
  +    └── main.ts
  +
  +9 directories, 10 files
  +```
  +
  +In a first time, we will create a simple Elm application.
  +
  +Create a `Main.elm` file inside the folder `packages/elm-app/app/src` with this content:
   
   ```elm
   module Main exposing(main)
  
positive.code: ```
  
  
  === Create a package
  create  folders
  
  ```shell
  mkdir -p packages/elm-app/{app,dist}
  ```
  
  because we will build with parcel and not with meteor, we will create a new file at the root of the meteor-elm-app called `.meteorignore`
  
  ```
  /packages/elm-app/app/**/*
  ```
  
  because we don't want to push the dist and the `elm-stuff` folders on our repository, we will add them in the .gitignore
  ```
  dist
  elm-stuff
  ```
  
  create a file package.js inside this folder:
  ```js
  Package.describe({
      name: 'elm-app',
  
negative.code:     return app.ports
  }
  ```
  
  With this definition, when we will need some flags or some ports, we will add the new stuff in our interface and the client will have to implement them.
  
  NOTE: Take care of the first line if you don't use SCSS but a `main.css` file
  
  === Build with parcel
  But... wait... why do we use Parcel? Why don't we use the Elm make command? Why don't we use the Meteor bundler for css?
  