The getAttribute('value') method retrieves the value of the HTML value attribute as it was defined in the initial page source. It does not reflect the live, current text a user has typed into the input field. To get the current value of an input element, you must use the .value property of the DOM element object. This property always holds the up-to-date content of the form control.

A. addCallback is not a standard DOM method for event handling; the correct method is addEventListener.

B. getElementByIdName is not a valid DOM method. Methods like getElementById or getElementsByName exist, but not this one.

D. The event type for addEventListener is "click". "onclick" is the name of the HTML attribute or object property, not the event type string.

1. MDN Web Docs, HTMLInputElement.value. "The value property of the HTMLInputElement interface gets or sets the current value of the element."

2. MDN Web Docs, Element.getAttribute(). "It is recommended that you use element.value to get the current value of a text input, because the value attribute does not dynamically update as the user types."

3. W3C, HTML Living Standard, Section 4.10.5.1.10 "The value attribute". "The value IDL attribute must reflect the current value of the element."

The code uses a ternary operator to set the display style property. The condition accountName.includes(parsedSearchString) is true when an account should be visible. Therefore, the value for the true case must be a valid CSS display value that makes the element visible, such as 'block'. The value for the false case (when the account does not match) must hide the element, for which 'none' is the correct CSS display value. The syntax is condition ? valueiftrue : valueiffalse.

B. 'none' : 'block'

This inverts the logic, hiding matching accounts and showing non-matching ones, which is the opposite of the requirement.

C. 'hidden' : 'visible'

'hidden' and 'visible' are values for the CSS visibility property, not the display property. They are not the correct values here.

D. 'visible' : 'hidden'

Similar to C, these are values for the visibility property and are incorrect for manipulating the display style property.

1. MDN Web Docs, "Conditional (ternary) operator": "The conditional (ternary) operator is the only JavaScript operator that takes three operands: a condition followed by a question mark (?), then an expression to execute if the condition is truthy followed by a colon (:), and finally the expression to execute if the condition is falsy." (Section: Syntax)

2. MDN Web Docs, "display - CSS: Cascading Style Sheets": "The display CSS property sets whether an element is treated as a block or inline element and the layout used for its children... A value of none turns off the display of an element so that it has no effect on layout."

3. Salesforce, Lightning Web Components Dev Guide, "Conditionally Render DOM Elements": "To conditionally render a DOM element in a template, add the if:true|false directive to a nested tag that encloses the conditional content." (While this is the LWC way, the question uses standard DOM manipulation, for which the CSS display property is correct.)

The execution flow logs the counter value at different points in time.

1. logCounter() is called immediately, logging the initial value of counter, which is 0.

2. setInterval starts, and after 1 second, it increments counter to 1 and logs 1.

3. After another second (at T=2s), setInterval increments counter to 2 and logs 2.

4. At T=2.1s, the setTimeout callback executes. It logs the current value of counter, which is 2.

The first four logged numbers are therefore 0, 1, 2, 2.

B. 0123: This would happen if setTimeout executed after the third setInterval tick, but its delay is 2100ms, which is before the T=3000ms tick.

C. 0112: This incorrectly assumes the counter is not updated before the second setInterval tick.

D. 0012: This would imply setTimeout ran before the first setInterval tick, which is incorrect as 2100ms is greater than 1000ms.

MDN Web Docs, setTimeout(): "The setTimeout() method of the WindowOrWorkerGlobalScope mixin sets a timer which executes a function or specified piece of code once the timer expires." (GlobalObjects/setTimeout)

MDN Web Docs, setInterval(): "The setInterval() method...repeatedly calls a function or executes a code snippet, with a fixed time delay between each call." (API/setInterval)

MDN Web Docs, Concurrency model and the event loop: "JavaScript has a runtime model based on an event loop, which is responsible for executing the code, collecting and processing events, and executing queued sub-tasks." (JavaScript/EventLoop)

Node.js heavily uses an event-driven architecture, particularly for asynchronous operations like starting a server. The EventEmitter class is the foundation for this pattern. Objects that are event emitters, like the server object described, use the .on(eventName, listener) method to register a callback function (the listener) that executes when a specific event is emitted. The conventional name for error events is 'error'. Therefore, server.on('error', callback) is the standard, idiomatic way to listen for and handle asynchronous errors from such an object.

A. server.error() is not a standard method in the Node.js EventEmitter API for registering an error listener.

B. server.catch() is the syntax for handling rejected Promises. The question specifies the library uses "events and callbacks," not Promises.

C. try...catch blocks only handle synchronous errors. An error during server boot-up (e.g., port in use) is typically an asynchronous event and would not be caught by this block.

1. Node.js Official Documentation, events module. The documentation clearly shows that emitter.on(eventName, listener) is the method to add a listener function for a named event.

2. Node.js Official Documentation, Error Handling. The section on Error Events states, "When an asynchronous method has an error, the error is passed to the callback... For EventEmitter classes, errors are routed to the 'error' event."

The literal 'use strict' inside myFunction activates strict mode only for that function’s body (ECMAScript allows function-level strictness).

Outside the function, code executes in non-strict (sloppy) mode.

• Line 08 assigns z = x (3.14) successfully, so z == 3.14 (B).

• Strict mode applies to every statement inside myFunction (lines 05 only), not to outer code—thus it “has effect only on line 05” (D).

• Inside strict code, assigning to an undeclared identifier (y = x) throws a ReferenceError (E).

A. Directive is not global; it does not affect lines before/after the function.

C. Scope is limited to the function, not the entire file after line 04.

1. ECMAScript 2021 §12.1.1 “Directive Prologues and Strict Mode” – strict mode can be function-local.

2. ECMAScript 2021 §15.1.1.1 – in strict mode, assignment to an undeclared variable throws ReferenceError.

3. Stanford CS142 lecture notes, “JavaScript Strict Mode,” Slide 6 – emphasises function-level granularity and resulting errors.

The import statement is used to import bindings that are exported by another module. When a module uses a default export for a function, you can import it without curly braces {} and assign it any local name. The question states printDate() is the default export. The code import printDate from ... correctly imports the default function and names it printDate locally. It is then invoked directly as printDate().

A. import DatePrettyPrint() from ... is invalid syntax; parentheses are not used when importing a function.

B. This syntax implies DatePrettyPrint is an object with a printDate method, which contradicts that printDate itself is the default export.

C. This imports the function as printDate but then incorrectly tries to call it as a method on an undefined DatePrettyPrint object.

1. MDN Web Docs, "JavaScript reference", import statement. Section: "Importing defaults". It shows the syntax import myDefault from '/modules/my-module.js';.

2. MDN Web Docs, "JavaScript reference", export statement. Section: "Default exports (one per module)". It clarifies that a default export can be a function, class, or object.

Promise.race() returns a promise that settles (fulfills or rejects) as soon as one of the input promises settles. In this scenario, car2 resolves in 1500ms, which is faster than car1 rejecting (2000ms) and car3 resolving (3000ms). Therefore, the Promise.race fulfills with the value of car2 ("Car 2 completed"). The .then() block is executed, and assuming the single quotes in the result assignment are a typo for backticks (template literal), the value of result becomes "Car 2 completed the race.".

B. car3 is the slowest promise to resolve (3000ms), so it cannot win the race.

C. The .catch() block is not executed because the race is won by a resolving promise (car2), not a rejecting one.

D. car1 rejects at 2000ms, which is slower than car2 resolving at 1500ms. The race is already over before car1 crashes.

1. MDN Web Docs, Promise.race(). "The Promise.race() static method takes an iterable of promises as input and returns a single Promise. This returned promise settles with the eventual state of the first promise that settles." (First paragraph).

2. ECMAScript® 2023 Language Specification, Section 27.2.4.6 Promise.race ( iterable ).

JavaScript execution is single-threaded and uses an event loop.

1. total is initialized to 10.

2. setInterval is called. Its callback function is placed in a macrotask queue to be executed later, even with a 0ms delay. It does not execute immediately.

3. The main script continues. total++ on line 07 is executed, incrementing total to 11.

4. console.log(total) on line 08 is executed. At this moment, the value of total is 11.

The setInterval callback only runs after the current call stack is empty, which happens after the entire main script, including the console.log, has finished executing.

B. The value 12 would be reached inside the setInterval callback, but the console.log executes before the callback runs.

C. The value is 10 initially, but total++ on line 07 executes before the console.log, making the value 11.

D. The value 13 is the final value of total after the callback has fully executed, which occurs after the console.log statement.

1. MDN Web Docs, The event loop. "The event loop's job is to look at the call stack and the callback queue. If the call stack is empty, it will take the first event from the queue and will push it to the call stack, which effectively runs it." (developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop)

2. Node.js Documentation, The Node.js Event Loop, Timers, and process.nextTick(). "When you call setTimeout(), the timer is inserted into the Timers phase... A timer callback will be run as early as it can be scheduled after the specified amount of time has passed." (nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/)

In JavaScript, there are two categories of data types: primitive types and objects. null is a primitive value that represents the intentional absence of any object value. However, due to a bug in the original implementation of JavaScript (ECMAScript), the typeof operator incorrectly returns the string "object" for the primitive value null. This behavior has been maintained for backward compatibility and is a well-known language quirk. Therefore, typeof null evaluates to "object".

B. "undefined": The typeof operator returns "undefined" only for the primitive value undefined or for undeclared variables.

C. "x": The typeof operator returns a string representing the data type of its operand, not the name of the variable itself.

D. "null": While logical, this is not the actual return value. To check specifically for null, one must use the strict equality operator (x === null).

Mozilla Developer Network (MDN): typeof operator, "typeof null" section.

ECMAScript® 2023 Language Specification: Section 13.5.3 The typeof Operator, Table 37: typeof Operator Results (Note for Null: "object").

Axel Rauschmayer, "Speaking JavaScript: An In-Depth Guide for Programmers", O'Reilly Media, 2014, Chapter 1, Section "A Bug: typeof null".