In HTML5, which JavaScript objects are not directly accessible from inside a Web Worker, and how does this restriction affect what a worker can do?

Introduction / Context:
Web Workers allow JavaScript code to run in background threads, but they operate in a more restricted environment than the main browser thread. Understanding which objects are not accessible from a Web Worker is important because it determines what tasks can be safely moved off the user interface thread. Interview questions commonly ask about these limitations, especially around access to the Document Object Model and global window context.

Given Data / Assumptions:
We are dealing with dedicated Web Workers in HTML5 compatible browsers.The question asks which objects are not directly accessible from inside a worker.We assume that workers communicate with the main thread using message passing.We focus on DOM related objects and global browser objects rather than every possible API.

Concept / Approach:
Web Workers run in an isolated context that does not share the same global window object or Document Object Model as the main page. This design avoids many concurrency and synchronization problems. Workers therefore do not have direct access to window, document, parent, or other DOM interfaces that would allow them to change the page structure. However, they do have access to a subset of browser APIs such as timers, a worker scoped self or dedicated global, and often XMLHttpRequest or fetch for network requests. Interaction with the user interface is achieved indirectly through messages sent back to the main thread, which then updates the DOM as needed.

Step-by-Step Solution:
First, recall that one of the core rules of Web Workers is that they cannot directly manipulate the Document Object Model.Next, note that DOM manipulation normally goes through window, document, and related objects.Then, understand that workers instead use postMessage to send data to the main thread, which still has access to the DOM.After that, evaluate the options for a statement that highlights the inaccessibility of window and document from within a worker.Finally, see that option A accurately captures this restriction and explains its implication on page structure manipulation.

Verification / Alternative check:
Practical code examples show that attempting to use document.getElementById directly inside a worker results in an error because document is undefined in that context. Similarly, referring to window or parent is not allowed. On the other hand, many browsers allow workers to use XMLHttpRequest or fetch and timer functions, which demonstrates that not every API is blocked. This real behavior confirms that the key limitation is around DOM related objects, as described in option A.

Why Other Options Are Wrong:
Option B claims that the navigator object is never accessible, but worker environments often expose a limited navigator for basic information. Option C says that setTimeout and setInterval are completely unavailable, which is not generally correct, because workers typically offer timers. Option D asserts that XMLHttpRequest is always blocked, yet workers can usually perform network requests in many implementations. Option E suggests that all built in JavaScript objects such as Array and Date are blocked, which is clearly false because workers rely on these standard language features for computation.

Common Pitfalls:
A common pitfall is designing worker code that tries to update user interface elements directly, which fails because of the lack of DOM access. Developers must instead plan message based communication and let the main thread handle all visual updates. Another mistake is assuming that every browser exposes exactly the same worker APIs, so it is important to check compatibility when using more advanced functions. Keeping in mind that workers are for computation and not for direct DOM manipulation leads to more robust and portable designs.

Final Answer:
The correct answer is: DOM related objects such as window, document, and parent are not accessible, so a worker cannot directly manipulate the page structure.