diff --git a/dev/src/App.svelte b/dev/src/App.svelte
index 7152b86..204f071 100644
--- a/dev/src/App.svelte
+++ b/dev/src/App.svelte
@@ -1,8 +1,9 @@
 <script>
 	import { useTooltip } from '../../src'
 
+	let tooltipPosition = 'top'
 	let useCustomTooltipClass = false
-	let animateTooltip = false
+	let isTooltipDisabled = false
 
     const _onTooltipClick = (arg, event) => {
 		console.log(arg)
@@ -12,50 +13,46 @@
 <main>
 	<div class="container">
 		<div use:useTooltip={{
-					contentSelector: '.tooltip__content',
+			        position: tooltipPosition,
+					contentSelector: '.tooltip__button',
 					contentClone: false,
 					contentActions: {
-						 '#button1': {
-            eventType: 'mouseenter',
-            callback: (arg) => console.log(arg),
-            callbackParams: ['Haha you\'re hovering the button 1'],
-            closeOnCallback: false
-        },
-        '#button2': {
-            eventType: 'mouseenter',
-            callback: (arg1, arg2) => console.log(arg1, arg2),
-            callbackParams: ['Haha you\'re hovering the', 'button 2'],
-            closeOnCallback: false
-        },
-        '#button2': {
-            eventType: 'click',
-            callback: (arg1, arg2) => console.log(arg1, arg2),
-            callbackParams: ['Haha you\'ve clicked the', 'button 2'],
-            closeOnCallback: true
-        },
+						'*': {
+							eventType: 'click',
+							callback: _onTooltipClick,
+							callbackParams: ['ok'],
+							closeOnCallback: true
+						},
 					},
 					contentClassName: useCustomTooltipClass ? 'tooltip' : null,
-					disabled: false,
-					animated: animateTooltip
-				}} class="tooltip__target">Hover me</div>
-        <span class="tooltip__content">
-			<button id="button1">Action 1</button>
-			<button id="button2">Action 2</button>
-		</span>
+					disabled: isTooltipDisabled,
+				}} class="target">Hover me</div>
+        <span class="tooltip__button">Hi! I'm a fancy tooltip!</span>
 		<form class="settings__form">
 			<h1>Settings</h1>
+            <fieldset>
+                <label>
+                    Use Custom Tooltip Class:
+                    <input type="checkbox" bind:checked={useCustomTooltipClass} />
+                </label>
+            </fieldset>
 			<fieldset>
 				<label>
-					Use Custom Tooltip Class:
-					<input type="checkbox" bind:checked={useCustomTooltipClass} />
-				</label>
-			</fieldset>
-			<fieldset>
-				<label>
-					Animate tooltip:
-					<input type="checkbox" bind:checked={animateTooltip} />
+					Tooltip Position:
+					<select bind:value={tooltipPosition}>
+                        <option value="left">Left</option>
+                        <option value="right">Right</option>
+                        <option value="top">Top</option>
+                        <option value="bottom">Bottom</option>
+                    </select>
 				</label>
 			</fieldset>
+            <fieldset>
+                <label>
+                    Disable Tooltip:
+                    <input type="checkbox" bind:checked={isTooltipDisabled} />
+                </label>
+            </fieldset>
 		</form>
 	</div>
 </main>
@@ -76,7 +73,7 @@
 		row-gap: 1rem;
 	}
 
-	.tooltip__target {
+	.target {
 		width: 10rem;
         height: 3rem;
         background-color: white;
@@ -87,16 +84,12 @@
         box-shadow: 0 0 5px 0 rgba(0,0,0,0.5);
 	}
 
-    .tooltip__target:hover {
+    .target:hover {
         cursor: pointer;
         background-color: black;
         color: white;
     }
 
-	.tooltip__content {
-		color: white
-	}
-
 	.settings__form {
 		display: flex;
 		flex-direction: column;
diff --git a/src/useTooltip.css b/src/useTooltip.css
index e250b00..068ca50 100644
--- a/src/useTooltip.css
+++ b/src/useTooltip.css
@@ -1,7 +1,7 @@
 .__tooltip__default {
     position: absolute;
     z-index: 9999;
-    max-width: 120px;
+    max-width: 100%;
     background-color: black;
     color: #fff;
     text-align: center;
@@ -12,10 +12,31 @@
 .__tooltip__default::after {
     content: "";
     position: absolute;
-    top: 100%;
-    left: 50%;
     margin-left: -5px;
     border-width: 5px;
     border-style: solid;
+}
+
+.__tooltip__top::after {
+    bottom: -10px;
+    left: 50%;
     border-color: black transparent transparent transparent;
+}
+
+.__tooltip__bottom::after {
+    top: -10px;
+    left: 50%;
+    border-color: transparent transparent black transparent;
+}
+
+.__tooltip__left::after {
+    top: calc(50% - 5px);
+    right: -10px;
+    border-color: transparent transparent transparent black;
+}
+
+.__tooltip__right::after {
+    top: calc(50% - 5px);
+    left: -5px;
+    border-color: transparent black transparent transparent;
 }
\ No newline at end of file
diff --git a/src/useTooltip.js b/src/useTooltip.js
index dc6632b..df44a23 100644
--- a/src/useTooltip.js
+++ b/src/useTooltip.js
@@ -2,27 +2,23 @@ import { DOMObserver } from '@untemps/dom-observer'
 
 import './useTooltip.css'
 
-const useTooltip = (node, { contentSelector, contentClone, contentActions, containerClassName, disabled, animated }) => {
+const useTooltip = (node, { position, contentSelector, contentClone, contentActions, contentClassName, disabled }) => {
 	Tooltip.init(contentSelector, contentClone)
 
-	const tooltip = new Tooltip(node, contentActions, containerClassName, animated)
-	if (disabled) {
-		tooltip.disable()
-	}
+	const tooltip = new Tooltip(node, position, disabled, contentActions, contentClassName)
 
 	return {
 		update: ({
+			position: newPosition,
 			contentSelector: newContentSelector,
 			contentClone: newContentClone,
 			contentActions: newContentActions,
-			containerClassName: newContainerClassName,
+			contentClassName: newContentClassName,
 			disabled: newDisabled,
-			animated: newAnimated,
 		}) => {
 			Tooltip.update(newContentSelector, newContentClone)
 
-			tooltip.update(newContentActions, newContainerClassName, newAnimated)
-			newDisabled ? tooltip.disable() : tooltip.enable()
+			tooltip.update(newPosition, newDisabled, newContentActions, newContentClassName)
 		},
 		destroy: () => {
 			tooltip.destroy()
@@ -38,23 +34,26 @@ export class Tooltip {
 	static #instances = []
 
 	#target = null
+	#position = null
 	#actions = null
-	#animated = false
 	#container = null
 	#events = []
 
 	#boundEnterHandler = null
 	#boundLeaveHandler = null
 
-	constructor(target, actions, className, animated) {
+	constructor(target, position, disabled, actions, className) {
 		this.#target = target
+		this.#position = position
 		this.#actions = actions
 		this.#container = Tooltip.#tooltip
-		this.#animated = animated
-
-		this.#className = className
-
-		this.#activateTarget()
+		
+		this.#container?.setAttribute('class', className || `__tooltip__default __tooltip__${this.#position}`)
+		
+		disabled ? this.#disable() : this.#enable()
+		
+		this.#target.title = ''
+		this.#target.setAttribute('style', 'position: relative')
 
 		Tooltip.#instances.push(this)
 	}
@@ -102,57 +101,42 @@ export class Tooltip {
 		Tooltip.#isInitialized = false
 	}
 
-	get #className() {
-		return this.#container?.getAttribute('class')
-	}
-
-	set #className(value) {
-		this.#container?.setAttribute('class', value || '__tooltip__default')
-	}
-
-	update(actions, className, animated) {
+	update(position, disabled, actions, className) {
+		this.#position = position
 		this.#actions = actions
-		this.#className = className
-		this.#animated = animated
+		
+		this.#container?.setAttribute('class', className || `__tooltip__default __tooltip__${this.#position}`)
+		
+		if(!disabled && !this.#boundEnterHandler) {
+			this.#enable()
+		} else if(disabled && !!this.#boundEnterHandler) {
+			this.#disable()
+		}
 	}
 
 	destroy() {
-		this.#deactivateTarget()
-		this.#removeContainerFromTarget();
+		this.#removeContainerFromTarget()
+		
+		this.#disable()
 	}
-
-	enable() {
+	
+	#enable() {
 		this.#boundEnterHandler = this.#onTargetEnter.bind(this)
 		this.#boundLeaveHandler = this.#onTargetLeave.bind(this)
-
+		
 		this.#target.addEventListener('mouseenter', this.#boundEnterHandler)
 		this.#target.addEventListener('mouseleave', this.#boundLeaveHandler)
 	}
-
-	disable() {
+	
+	#disable() {
 		this.#target.removeEventListener('mouseenter', this.#boundEnterHandler)
 		this.#target.removeEventListener('mouseleave', this.#boundLeaveHandler)
-
+		
 		this.#boundEnterHandler = null
 		this.#boundLeaveHandler = null
 	}
 
-	#activateTarget() {
-		this.#target.title = ''
-		this.#target.setAttribute('style', 'position: relative')
-
-		this.enable()
-	}
-
-	#deactivateTarget() {
-		this.disable()
-	}
-
-	async #appendContainerToTarget() {
-		if(this.#animated) {
-			await this.#manageTransition(1)
-		}
-
+	#appendContainerToTarget() {
 		this.#target.appendChild(this.#container)
 
 		if (this.#actions) {
@@ -172,60 +156,55 @@ export class Tooltip {
 		}
 	}
 
-	async #removeContainerFromTarget() {
-		if(this.#animated) {
-			await this.#manageTransition(0)
+	#removeContainerFromTarget() {
+		if (this.#target.contains(this.#container)) {
+			this.#target.removeChild(this.#container)
 		}
 
-		this.#container.remove()
-
 		this.#events.forEach(({ trigger, eventType, listener }) => trigger.removeEventListener(eventType, listener))
 		this.#events = []
 	}
 
-	#manageTransition(direction) {
-		return new Promise((resolve) => {
-			let classToAdd, classToRemove
-			switch(direction) {
-				case 1: {
-					classToAdd = '__tooltip__show'
-					classToRemove = '__tooltip__hide'
+	#onTargetEnter() {
+		this.#appendContainerToTarget()
+
+		Tooltip.#observer.wait(`#tooltip`, null, { events: [DOMObserver.EXIST] }).then(({ node }) => {
+			const { width: targetWidth, height: targetHeight } = this.#target.getBoundingClientRect()
+			const { width: tooltipWidth, height: tooltipHeight } = this.#container.getBoundingClientRect()
+			switch(this.#position) {
+				case 'left': {
+					this.#container.style.top = `${-(tooltipHeight - targetHeight) >> 1}px`
+					this.#container.style.bottom = null
+					this.#container.style.left = `${-tooltipWidth - 6}px`
+					this.#container.style.right = null
+					break
+				}
+				case 'right': {
+					this.#container.style.top = `${-(tooltipHeight - targetHeight) >> 1}px`
+					this.#container.style.bottom = null
+					this.#container.style.right = `${-tooltipWidth - 6}px`
+					this.#container.style.left = null
+					break
+				}
+				case 'bottom': {
+					this.#container.style.left = `${-(tooltipWidth - targetWidth) >> 1}px`
+					this.#container.style.right = null
+					this.#container.style.bottom = `${-tooltipHeight - 6}px`
+					this.#container.style.top = null
 					break
 				}
 				default: {
-					classToAdd = '__tooltip__hide'
-					classToRemove = '__tooltip__show'
+					this.#container.style.left = `${-(tooltipWidth - targetWidth) >> 1}px`
+					this.#container.style.right = null
+					this.#container.style.top = `${-tooltipHeight - 6}px`
+					this.#container.style.bottom = null
 				}
 			}
-			this.#container.classList.add(classToAdd)
-			this.#container.classList.remove(classToRemove)
-
-			if(direction === 1) {
-				resolve()
-			}
-
-			const onTransitionEnd = () => {
-				this.#container.removeEventListener("animationend", onTransitionEnd)
-				this.#container.classList.remove(classToAdd)
-				resolve()
-			}
-			this.#container.addEventListener("animationend", onTransitionEnd)
-		})
-	}
-
-	async #onTargetEnter() {
-		await this.#appendContainerToTarget()
-
-		Tooltip.#observer.wait(`#tooltip`, null, { events: [DOMObserver.EXIST] }).then(({ node }) => {
-			const { width: targetWidth } = this.#target.getBoundingClientRect()
-			const { width: tooltipWidth, height: tooltipHeight } = this.#container.getBoundingClientRect()
-			this.#container.style.left = `${-(tooltipWidth - targetWidth) >> 1}px`
-			this.#container.style.top = `${-tooltipHeight - 6}px`
 		})
 	}
 
-	async #onTargetLeave() {
-		await this.#removeContainerFromTarget()
+	#onTargetLeave() {
+		this.#removeContainerFromTarget()
 	}
 }