In JavaScript ES6 modules, which are fundamental to Lightning Web Components (LWC), named exports are used to export multiple values from a single module. Each function, class, or variable to be exported is preceded by the export keyword or listed within an export statement's curly braces. This allows a consuming module to import specific functions by their names, promoting code reusability and organization. A module can have multiple named exports but only one default export.

A. all: all is not a valid JavaScript export keyword. The syntax import as name is used for importing, not exporting.

C. multi: multi is not a recognized keyword or type of export in the JavaScript module specification.

D. default: A module can have only one default export. While an object containing multiple functions could be default-exported, the standard mechanism for exporting multiple distinct functions is via named exports.

1. Salesforce Lightning Web Components Developer Guide:

Section: Share JavaScript Code

Content: The guide demonstrates creating a utils.js module that exports multiple functions using named exports. For example: export const getToday = () => { ... }; export const getNextWeek = () => { ... };. This directly illustrates the use of named exports for sharing multiple functions.

2. MDN Web Docs (Mozilla):

Document: export statement

Section: "Named exports"

Content: "Named exports are useful to export several values. During the import

it is mandatory to use the same name of the corresponding object." The documentation provides the syntax export { name1

name2

...

nameN };

which is the standard for exporting multiple items from a module.

3. Exploring JS by Dr. Axel Rauschmayer (University-level resource):

Chapter: Modules

Section: 17.3.1 "Named exports (several per module)"

Content: "A module can export multiple things by prefixing their declarations with the keyword export. These exports are distinguished by their names and are called named exports." This academic text clearly defines the purpose and terminology of named exports for exporting multiple values.

The window.localStorage API stores data as key-value pairs, where both the key and the value must be strings. To correctly persist a JavaScript object, it must first be serialized into a string format. The JSON.stringify() method accomplishes this by converting the object into a JSON string. The setItem(key, value) method is then used to store this string in local storage under the specified key. This ensures the object's data and structure are preserved and can be retrieved and parsed back into an object later using JSON.parse().

B: The connectObject method is not a valid function within the Web Storage API for localStorage.

C: The setItem method requires two string arguments (a key and a value); this code provides only one argument, which is an object.

D: The persist method does not exist on the window.localStorage object; it is not part of the standard Web Storage API.

---

1. Mozilla Developer Network (MDN) Web Docs: The Storage.setItem() method's documentation explicitly states that the value is converted to a UTF-16 string before being stored. It provides a direct example of using JSON.stringify() to store an object.

Source: MDN Web Docs

Storage.setItem(). Retrieved from https://developer.mozilla.org/en-US/docs/Web/API/Storage/setItem#settingavalue (See "Example" section).

2. W3C Recommendation - Web Storage (Second Edition): The official specification for the Web Storage API defines the setItem method within the Storage interface. It specifies the method signature as void setItem(DOMString key

DOMString value)

confirming that both arguments must be strings.

Source: W3C

"Web Storage (Second Edition)"

12 November 2020. Section 4.3

"The Storage interface". Retrieved from https://www.w3.org/TR/webstorage/#dom-storage-setitem.

The console.assert() method is used to verify that a given expression is true. The entire expression to be evaluated must be passed as the first argument. The correct syntax for testing a function's return value is console.assert(functionCall() == expectedValue).

Options A and C correctly place the entire comparison expression inside the console.assert() call. Although the sum3 function is called with non-array arguments (e.g., sum3(-3, 2) instead of sum3([-3, 2])), causing it to return 0 and the assertions to fail, the statements themselves are structurally valid as tests. A failing assertion is a valid and useful test result.

B. console.assert(sum3(0)) == 0);

This statement incorrectly places the comparison == 0 outside the console.assert() call, comparing its return value (undefined) to 0 instead of testing the function's result.

D. console.assert(sum3(‘hello’, 2, 3, 4)) === NaN);

Similar to option B, the comparison === NaN is outside the console.assert() call. This structure does not correctly test the return value of the sum3 function.

---

1. MDN Web Docs

console.assert():

Reference: The syntax is console.assert(assertion

...data). The assertion is any boolean expression. If the assertion is false or falsy

a message is written to the console.

Location: MDN Web Docs

console.assert() page

"Syntax" and "Parameters" sections. This source confirms that the entire logical condition must be the first parameter.

2. WHATWG

Console Standard:

Reference: The specification for assert(condition

...data) states: "If condition is true

then return." This implies the entire condition to be evaluated for its truthiness must be the first argument.

Location: WHATWG Console Standard

Section 3.3 assert()

steps 1-3.

3. MDN Web Docs

Functions:

Reference: "If a function is called with more arguments than there are named parameters

the extra arguments are ignored by the named parameters." For sum3(arg1

arg2)

the parameter arr will only receive arg1.

Location: MDN Web Docs

Functions

"Parameters". This supports the analysis of how the function behaves with the provided inputs in options A and C.

The goal is to override the load method inherited from GameConsole.prototype for instances of Console16bit. This is achieved by defining a new load method directly on the Console16bit.prototype object. Option B, Console16bit.prototype.load = function(gamename) {, uses the correct syntax to assign a new function to the load property of the child's prototype. When console16bit.load() is called, the JavaScript engine finds this new function on Console16bit.prototype first in the prototype chain and executes it, producing the desired specialized output.

A. Console16bit.prototype.load(gamename) = function() { is invalid syntax. It attempts to assign a function to the result of a method call, which is not a valid assignment target.

C. Console16bit = Object.create(GameConsole.prototype).load = function (gamename) { is incorrect because it reassigns the Console16bit constructor itself, rather than modifying its prototype.

D. Console16bit.prototype.load(gamename) { is syntactically incorrect. This shorthand method syntax is only valid within class definitions or object literals, not for direct prototype assignment.

1. Mozilla Developer Network (MDN) Web Docs: The official documentation for JavaScript explains how setting a property on a more specific object in the prototype chain "shadows" the property from the less specific object. "When you set a property to an object

the property is created on the object itself... If a property with the same name exists on the prototype chain

this is called shadowing."

Source: MDN Web Docs

Object prototypes

"Shadowing properties" section. developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritanceandtheprototypechain#shadowingproperties

2. Mozilla Developer Network (MDN) Web Docs: The documentation on Object.create() explains its role in setting up prototypal inheritance

as used on line 11 of the provided code

which is the foundation for the method override.

Source: MDN Web Docs

Object.create()

"Using Object.create() for prototypal inheritance" section. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/GlobalObjects/Object/create#usingobject.createforprototypalinheritance

3. University of Washington

Paul G. Allen School of Computer Science & Engineering Courseware: University course materials on JavaScript detail the mechanism of overriding methods by re-defining them on the "child" constructor's prototype.

Source: CSE 154: Web Programming

Lecture 13: JS Objects and Prototypes

Slide 34 ("Overriding Methods"). courses.cs.washington.edu/courses/cse154/18au/lectures/13/lecture13-js-objects-prototypes.pdf

When the JavaScript execution is paused by the debugger; statement, the browser's developer tools provide access to the current state of the application.

1. The line let carSpeed = document.getElementById('CarSpeed'); has already executed. Therefore, the carSpeed variable exists in the current scope and holds a reference to a DOM element. The developer tools allow for deep inspection of this object, including its properties like style, attributes, and any attached event listeners.

2. The window.localStorage property is part of the global window object. Global objects and their properties are always accessible from the console at any point during execution, including when paused at a breakpoint.

A. The fourWheels variable is declared on the line after the debugger; statement. Since execution is paused before this line runs, the variable has not yet been declared or initialized.

B. JavaScript does not have a built-in mechanism to automatically count the number of instances created from a constructor function or class. This functionality would need to be explicitly coded.

1. Mozilla Developer Network (MDN) Web Docs: In the "Debugging JavaScript - Pausing the code" guide

it is explained that when execution is paused

the "Scope" pane displays the variables currently in scope. This includes local variables that have been declared (like carSpeed) and global objects (like window

which contains localStorage). The guide also shows how to inspect the properties of these objects.

Source: MDN Web Docs

"Debugging JavaScript

" Section: "Pausing the code." (developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Debugging#pausingthecode)

2. Chrome for Developers Documentation: The official documentation for Chrome DevTools states

"When your code is paused

the Scope pane shows you what local

closure

and global variables are currently defined

along with the value of each." This confirms that the carSpeed (local) and window.localStorage (on the global window object) would be available for inspection. The documentation also details how to inspect DOM node properties.

Source: Chrome for Developers

"JavaScript debugging reference

" Section: "View and edit local

closure

and global properties." (developer.chrome.com/docs/devtools/javascript/reference#scope)

3. W3C WebDriver Specification (Working Draft): While not a direct tutorial

the specification for browser automation tools defines the runtime environment. It implicitly confirms that the state of the global object (like window) and the current execution context's variable environment are fundamental parts of the script state accessible during a debug pause.

Source: W3C WebDriver

Section 11.1 "Scripting Contexts." (www.w3.org/TR/webdriver/#scripting-contexts)

In JavaScript, objects are treated as reference types. The statement const objB = objA; does not create a new, independent object. Instead, it creates a new reference (objB) that points to the exact same object in memory as objA. When objB is passed to the changeValue function, the function modifies the value property of that single, shared object. Consequently, when objA.value is accessed, it reflects the updated value of 5.

A. 10: This would be the result if objects were passed by value, meaning a distinct copy of objA was created for objB, which is not the case.

B. NaN: This result (Not a Number) would occur from an invalid mathematical operation, but dividing 10 by 2 is a valid calculation.

D. Undefined: This would be the result if the value property did not exist on the object, but it was explicitly initialized with the value 10.

---

1. MDN Web Docs

JavaScript Guide: In the "Working with Objects" section

it is stated: "If an object is assigned to a variable

the variable in fact holds a reference (or a "pointer") to the object. If you then assign this variable to another variable

the new variable also holds a reference to the same object." This directly supports the explanation that objA and objB reference the same object.

Source: Mozilla

MDN Web Docs

"JavaScript Guide > Working with Objects > Objects as references".

2. Eloquent JavaScript

3rd Edition: Chapter 4

"Data Structures: Objects and Arrays"

in the section on "Mutability"

explains: "The bindings object1 and object2 grasp the same object... If you change object1

you are also changing object2." This principle is identical to the behavior of objA and objB in the question.

Source: Haverbeke

M. (2018). Eloquent JavaScript (3rd ed.). No Starch Press. Chapter 4

"Mutability".

3. University of Washington

CSE 154: Web Programming: Course materials on JavaScript objects explain that when you assign one object variable to another

you are copying the reference (the "arrow")

not the object itself. Modifying the object through one variable affects the other.

Source: University of Washington

Paul G. Allen School of Computer Science & Engineering

CSE 154: Web Programming

Lecture 10: "JS Objects"

Slide on "Objects as Parameters: Reference Mystery".

The core of this question lies in the behavior of JSON.stringify(). This method converts a JavaScript object to a JSON string, but it only serializes data properties. According to the ECMAScript specification, properties whose values are functions, undefined, or Symbols are omitted during the serialization of an object. In the provided code, the name property of the john object is a function. Therefore, it is excluded from the JSON string created by JSON.stringify(john). When this string is parsed back into an object with JSON.parse(), the resulting dan object has the firstName and lastName properties but lacks the name method. The subsequent call to dan.name() attempts to invoke an undefined property, which results in a TypeError.

A. Hello Dan Doe: This is incorrect because the name method is not transferred to the dan object during the JSON serialization/deserialization process.

B. Hello John Doe: This is incorrect for the same reason as option A. The dan object does not inherit or copy the name method.

D. TypeError: Assignment to constant variable.: This is incorrect. The const declaration prevents the variable dan from being reassigned, but it does not make the object it references immutable. Modifying a property of the object (dan.firstName = 'Dan') is a valid operation.

1. Mozilla Developer Network (MDN) Web Docs: In the documentation for JSON.stringify()

under the "Description" section

it states: "If undefined

a Function

or a Symbol is encountered during conversion it is either omitted (when it is found in an object) or censored to null (when it is found in an array)." This directly confirms that the name function will be omitted. (Source: MDN Web Docs

JSON.stringify())

2. ECMAScript® 2022 Language Specification (ECMA-262

13th Edition): The official standard for JavaScript defines the serialization process. In section 25.5.2.1 SerializeJSONObject ( state

value )

step 4.c describes iterating through an object's properties. Sub-step ii specifies that if the property's value is undefined

a Symbol

or a Function

the property is skipped and not included in the output string. This formalizes the behavior observed in the question. (Source: ECMA International

ECMA-262 Standard

Section 25.5.2.1)

The question requires setting up an event and a callback to handle the server start-up process, which is a core pattern in Node.js's asynchronous, event-driven architecture. The server.on('eventName', callback) syntax is the standard method for registering an event listener. Option B correctly uses this pattern by attaching a listener to the server object for a 'connect' event. When this event is emitted by the library (signifying the server is ready), the provided callback function (port) => { console.log(...) } is executed.

A. Server.start(); is a synchronous, procedural call, not the event-driven pattern described. It also uses incorrect capitalization for the server variable.

C. server() invokes the imported module as a function. While some frameworks use this to create an app instance, it does not register an event listener.

D. serve(( port) => ( is syntactically incorrect, uses the wrong variable name (serve instead of server), and is an incomplete statement.

E. console.log( ‘Listening on ’, port); is only a logging statement. It would be placed inside a callback but does not set up the event listener itself.

1. Node.js Official Documentation

EventEmitter Class: The fundamental pattern is based on the EventEmitter class. The emitter.on(eventName

listener) method adds the listener function to the end of the listeners array for the event named eventName.

Source: Node.js v18.17.1 Documentation

events module.

Section: Class: EventEmitter

emitter.on(eventName

listener).

2. Node.js Official Documentation

Net Module: The built-in net.Server class

which is the basis for many server libraries

is an EventEmitter and emits events like connection and listening. This demonstrates the real-world application of the pattern in the question.

Source: Node.js v18.17.1 Documentation

net module.

Section: Class: net.Server

Event: 'listening'. The documentation states

"Emitted when the server has been bound after calling server.listen()."

3. MIT OpenCourseWare

6.170 Software Studio

Lecture 19: Node.js: University courseware explains that Node.js is built around an asynchronous event-driven architecture. Callbacks are registered for events

and the event loop invokes them when the corresponding event occurs. The object.on('event'

callback) pattern is central to this model.

Source: MIT OpenCourseWare

6.170 Software Studio

Spring 2013.

Reference: Lecture 19 Notes

Section on "Events".

The Object.freeze() method is used to make an existing object immutable. When an object is frozen, its properties cannot be altered in any way. This means new properties cannot be added, existing properties cannot be removed, and the values of existing properties cannot be changed. The method also prevents the modification of property descriptors (writable, configurable, enumerable). This directly fulfills the requirement to prevent properties from being added or modified.

A. Object.const() is incorrect because const is a keyword for variable declaration, not a method on the Object constructor. A const variable cannot be reassigned, but if it holds an object, the object's properties remain mutable.

B. Object.eval() is incorrect as eval() is a global function, not an Object method. It evaluates JavaScript code represented as a string and is unrelated to object immutability.

C. Object.lock() is incorrect because it is not a standard, built-in method in the JavaScript Object API.

---

1. Mozilla Developer Network (MDN) Web Docs

Object.freeze():

Section: Description

Content: "The Object.freeze() static method freezes an object. Freezing an object prevents extensions and makes existing properties non-writable and non-configurable. A frozen object can no longer be changed... The method returns the object that was passed in."

Source: MDN Web Docs: Object.freeze()

2. Salesforce Developers

Lightning Web Components Dev Guide:

Section: Reactivity > Non-Reactive Properties

Content: "To create private properties that are non-reactive

use symbols or other conventions. To prevent an object from being mutated

use Object.freeze()." This officially sanctions Object.freeze() for creating immutable objects in a Salesforce context.

Source: Salesforce Lightning Web Components Developer Guide

3. Mozilla Developer Network (MDN) Web Docs

const:

Section: Description

Content: "The const declaration creates a read-only reference to a value... It does not mean the value it holds is immutable—just that the variable identifier cannot be reassigned. For instance

in the case where the content is an object

this means the object's contents (e.g.

its properties) can be altered."

Source: MDN Web Docs: const

The code on line 05 uses a conditional (ternary) operator to set the display style property of an HTML element. The operator's structure is condition ? valueiftrue : valueiffalse.

The condition accountName.includes(parsedSearchString) evaluates to true if the account should be visible. Therefore, the valueiftrue must be a valid CSS display value that makes the element visible, such as 'block'. If the condition is false, the account should be hidden, so the valueiffalse must be 'none'.

The expression 'Block' : 'none' provides these values. CSS property values like block are case-insensitive, so 'Block' is treated as 'block'.

A. ' name ' : ' block ': This uses an invalid CSS value ('name') for the display property and reverses the intended logic.

C. ' visible ' : ' hidden ': These are valid values for the CSS visibility property, not the display property being set in the code.

D. ' hidden ' : ' visible ': These are also values for the visibility property and are therefore incorrect for setting the display property.

---

1. Mozilla Developer Network (MDN) Web Docs

HTMLElement.style: This document explains that the style property is used to get and set the inline style of an element. Individual properties like display are accessed directly (e.g.

element.style.display). This confirms the mechanism used in the code.

Source: Mozilla

"HTMLElement.style"

Accessed [Current Date]

https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style

2. Mozilla Developer Network (MDN) Web Docs

display (CSS Property): This official documentation lists the valid values for the CSS display property. It specifies 'block' as a value that makes an element a block-level element

and 'none' as the value that turns off the display of an element

removing it from the document's layout entirely.

Source: Mozilla

"display"

CSS: Cascading Style Sheets

Accessed [Current Date]

https://developer.mozilla.org/en-US/docs/Web/CSS/display (See "Values" section for block and none).

3. Mozilla Developer Network (MDN) Web Docs

Conditional (ternary) operator: This resource details the syntax and usage of the ternary operator in JavaScript as condition ? exprIfTrue : exprIfFalse. This confirms the structure of the code on line 05 and how the chosen values will be applied based on the condition's result.

Source: Mozilla

"Conditional (ternary) operator"

JavaScript Guide

Accessed [Current Date]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/ConditionalOperator