You really think throwing is preferable over an actual default case? From my point of view that second snippet is way more smellier than the first one. Having to wrap it on a try/catch in order to be "safe" makes it usage way less convenient.

My suggestion would be to just have something simple like this (added JSDocs to make DX even better):

const modelBrandMap = /** @type {const} */ ({
    A4: "Audi",
    AMG: "Mercedes-Benz",
});

/**
 * @template {keyof typeof modelBrandMap} Model
 * @param {Model} model
 */
const carBrand = model => modelBrandMap[model];

And then the usage is as simple as:

// We can graceful default the brand to "Unknown":

console.log(`The brand for "${model}" is "${carBrand(model) ?? "Unknown"}".`);

// Or if you prefer to show an error, you can always:

const brand = carBrand(model);

brand
    ? console.log(`The brand for "${model}" is "${brand}"`)
    : console.error(`There's no brand for "${model}"`);

// Or maybe using if:

const brand = carBrand(model);

if (brand) {
    console.log(`The brand for "${model}" is "${brand}"`);
} else {
    console.error(`There's no brand for "${model}"`);
}

As you can see, we have several options, none of which will make the app explode for not finding a result. Now with your approach we have less options and we need to use more boilerplate:

// The graceful approach:

try {
    console.log(`The brand for "${model}" is "${carBrandExplicit(model)}".`);
} catch {
    console.log(`The brand for "${model}" is "Unknown".`);
}

// Or maybe you want to reduce duplication of code, so yo do something like (which still isn't pretty):

let brand = "Unknown";
try {
    brand = carBrandExplicit(model);
} catch {}

console.log(`The brand for "${model}" is "${brand}".`);

// If we prefer to show the error:

try {
    console.log(`The brand for "${model}" is "${carBrandExplicit(model)}"`);
} catch (error) {
    console.error(error);
}

But basically less options and more boilerplate just because you took the nuclear option of throwing. Take a look at native methods such as Array.prototype.find: When it finds an item that matches the predicate function, it returns it, but if it doesn't find it, it doesn't throw, instead it just returns undefined. The developer already knows that if the value received is undefined, it means the item wasn't found, so no need to throw for that. In TypeScript or JS with type check enabled you get the type TypeOfItem | undefined from it, so you know you need to check for undefined or use ?? to be safe. Typing for errors is way more nasty (you need to use asserts to create invariants for every function that throws).

We can go simpler than that, with any function and operation that returns a number, if an operation to get a number is invalid, you get the infamous NaN, which is still not throwing. Developers really don't want to have to wrap every single function call in a try/catch block, so you really should avoid that as a practice, even if it is "good" in other languages.

Cheers!

The functionality of the two code samples is different

But that's the bouncer pattern, no? Lot's of devs prefer it over else 🙃