How can you handle cross-origin resource sharing (CORS) in JavaScript when making AJAX requests?

In JavaScript, event bubbling and event capturing are two mechanisms that describe how events propagate through the DOM (Document Object Model) hierarchy. These mechanisms determine the order in which event handlers are invoked when multiple elements are nested inside each other and an event occurs.

1. Event Bubbling:
Event bubbling is the default behavior in most web browsers. When an event is triggered on an element, such as a click event, the event starts at the target element and then bubbles up through its parent elements in the DOM hierarchy, all the way up to the root of the document. This means that the event is first handled by the innermost element and then successively propagated to its parent elements.

For example, consider a scenario where you have a `<div>` element nested inside another `<div>`, and both have click event handlers attached:

```
html`<div id="outer">
<div id="inner"></div>
</div>`
```

```
javascript`document.getElementById('outer').addEventListener('click', function() {
console.log('Outer div clicked');
});

document.getElementById('inner').addEventListener('click', function() {
console.log('Inner div clicked');
});`
```
When you click on the inner `<div>`, the event will trigger its event handler first, logging "Inner div clicked" to the console. Then, the event will bubble up to the outer `<div>`, triggering its event handler and logging "Outer div clicked" to the console.

Event bubbling allows you to handle events in a more general and convenient way, as you can attach a single event listener to a parent element and handle events from multiple child elements.

2. Event Capturing:
Event capturing is the reverse process of event bubbling. It is less commonly used but still supported by the DOM. With event capturing, the event is first captured by the outermost element and then propagates down through its descendant elements to the target element.

To enable event capturing, you can set the third parameter of the `addEventListener` method to `true`. By default, it is `false`, which represents event bubbling.

```
javascript`document.getElementById('outer').addEventListener('click', function() {
console.log('Outer div clicked');
}, true);

document.getElementById('inner').addEventListener('click', function() {
console.log('Inner div clicked');
}, true);`
```
In the above example, when you click on the inner `<div>`, the event will trigger the event handler of the outer `<div>` first, logging "Outer div clicked" to the console. Then, the event will capture the inner `<div>` and trigger its event handler, logging "Inner div clicked" to the console.

Event capturing can be useful in specific scenarios where you need to intercept and handle events at the root level or any intermediate ancestor element.

3. Stopping Event Propagation:
Both event bubbling and event capturing can be stopped or prevented at any point in the propagation chain. This is done using the `stopPropagation` method of the event object.

```
javascript`document.getElementById('inner').addEventListener('click', function(event) {
event.stopPropagation();
console.log('Inner div clicked');
});`
```
In the above example, when you click on the inner `<div>`, the event handler of the outer `<div>` will not be triggered, and only "Inner div clicked" will be logged to the console.

Understanding event bubbling and event capturing is crucial for managing event handling and preventing unintended side effects. By leveraging these mechanisms, you can create more interactive and dynamic web applications with proper event delegation and efficient event handling.