Why can't I `export default` a constant inline with its definition?

Question

I can define a function and then export as default, define it an export it inline, or define it and export it as default inline:

function myFunc() {
    ...
}
export default myFunc;

export function myFunc2() {
    ...
}

export default function myFunc3(param) {
    ...
}

I can define a class and then export as default, define it and export it inline, or define it and export it as default inline:

class MyClass {
    ...
}
export default MyClass;

export class MyClass2 {
    ...
}

export default class MyClass3 {
    ...
}

Cool, so classes and functions are consistent. Now, constants:

Define and then export as default:

const myConst = 42;
export default myConst;

Define and export inline:

export const myConst = 42;

Those are fine. But I cannot define it and export as default inline:

export default const myConst = 42; // nope -- syntax error!

My question: why are constants different than classes and functions in this regard? They're all exportable, all exportable as defaults. Why can't I do it inline with a constant?

I found Why Is `Export Default Const` invalid? while googling. I believe the asker was trying to ask the same question I am, but there is a highly upvoted, accepted answer which does not answer my question. I am not asking for the technical reason the compiler rejects the syntax. I am looking to understand why the language is designed this way.

If it helps, the answer might take the form of "if this syntax were supported, [thing] would happen," or "it used to work that way, but we removed it because [thing] happened," or "there's an open discussion on adding this to the spec, see [here]."

If the distinction between TypeScript and JavaScript is in any way relevant to the answer, please clarify.

Answer 1

I just scanned through Why is "export default var a = 1;" invalid syntax? at ES Discuss. After doing so, it seems to me that it has something to do with the differences in the nature of the concepts of binding declarations and default exports.

You can declare multiple bindings in one statement like this:

const a = 1, b = 2, c = 3;

But the default export has to be just a single expression. Therefore, the concepts of declarations and default exports cannot be matched in a logical sense, so trying to combine them in a one-liner just cannot be done syntactically. It cannot be determined what the default export in the following statement should be:

export default const a = 1, b = 2, c = 3;

Functions and classes do not have these issues. You cannot declare multiple functions or classes in a single statement like you can with bindings/variables. So functions and classes can be declared as default exports in a one-liner.

Answer 2

Have a look at why JavaScript has default exports at all. They were introduced as syntactic sugar:

export default function example() {}
// is the same as
function example() {}
export { example as default }

export default class Example {}
// is the same as
class Example {}
export { Example as default }

export default (expression);
// is the same as
let *default* = (expression);
export { *default* as default }

export is not a modifier you can slap onto any declaration, it is a separate kind of declaration statement.

Default exports/imports are meant to simplify the common use case of a module exporting a single function or class, under an insignificant name (that's why they even allow anonymous declarations) - large entities for which it makes sense to create an entire module (or just following the Java "one file per class" pattern). A constant value is not something you'd generally create an own module for, so it got no special syntactic sugar. Go with

const myConst = 42;
export { myConst as default};

or (if you don't actually need the local name)

export default 42;