Use this before calling "FollowSymbols" from separate threads to avoid concurrent map update hazards.

Returns the canonical ref that represents the ref for the provided symbol.

Makes "old" point to "new" by joining the linked lists for the two symbols together.

If true, "assert { type: 'json' }" was present.

If true, calls to this symbol can be unwrapped (i.e.

Tell the printer to use the runtime "__require()" instead of "require()".

If true, this "export * from 'path'" statement is evaluated at run-time by calling the "__reExport()" helper function.

If this is true, the import contains an import for the alias "default", either via the "import x from" or "import {default as x} from" syntax.

If this is true, the import contains an import for the alias "__esModule", via the "import {__esModule} from" syntax.

If this is true, the import contains syntax like "* as ns".

Unique keys are randomly-generated strings that are used to replace paths in the source code after it's printed.

If this is present, the symbol could potentially be overwritten.

If true, this symbol is the target of a "__name" helper function call.

This flag is to avoid warning about this symbol more than once.

True for the following cases: try { require('x') } catch { handle } try { await import('x') } catch { handle } try { require.resolve('x') } catch { handle } import('x').catch(handle) import('x').then(_, handle) In these cases we shouldn't generate an error if the path could not be resolved.

A CSS "@import" rule.

A CSS "composes" declaration.

An "import()" expression with a string argument.

An entry point provided by the user.

The linker doesn't report import/export mismatch errors.

The printer will replace this import with "undefined".

A call to "require()".

A call to "require.resolve()".

An ES6 import or re-export statement.

A CSS "url(...)" token.

This means the symbol is a normal function that has no body statements.

If true, this import can be removed if it's unused.

This means the symbol is a normal function that takes a single argument and returns that argument.

Sometimes the parser creates an import record and decides it isn't needed.

Certain symbols must not be renamed or minified.

In React's version of JSX, lower-case names are strings while upper-case names are identifiers.

Sometimes we lower private symbols even if they are supported.

This is used to remove the all but the last function re-declaration if a function is re-declared multiple times like this: function foo() { console.log(1) } function foo() { console.log(2) } .

If true, do not generate "external": true in the metafile.

This is the special "arguments" variable inside functions.

There's a weird special case where catch variables declared using a simple identifier (i.e.

Classes can merge with TypeScript namespaces.

Class names are not allowed to be referenced by computed property keys.

Assigning to a "const" symbol will throw a TypeError at runtime.

Generator and async functions are not hoisted, but still have special properties such as being able to overwrite previous functions with the same name.

CSS identifiers that are never renamed.

This has special merging behavior.

In TypeScript, imports are allowed to silently collide with symbols within the module.

Injected symbols can be overridden by provided defines.

Labels are in their own namespace.

CSS identifiers that are renamed to be unique to the file they are in.

Properties can optionally be renamed to shorter names.

This annotates all other symbols that don't have special behavior.

A class-private identifier (i.e.

TypeScript enums can merge with TypeScript namespaces and other TypeScript enums.

TypeScript namespaces can merge with classes, functions, TypeScript enums, and other TypeScript namespaces.

An unbound symbol is one that isn't declared in the file it's referenced in.

This flags all symbols that were exported from the module using the ES6 "export" keyword, either directly on the declaration or using "export {}".

CSS "@import" of an empty file should be removed.

If true, this was originally written as a bare "import 'file'" statement.

Tell the printer to wrap this ESM exports object in "__toCJS(...)".

Tell the printer to wrap this call to "require()" in "__toESM(...)".

This stores a 32-bit index where the zero value is an invalid index.

Files are parsed in parallel for speed.

Note: the order of values in this struct matters to reduce struct size.

This is a histogram of character frequencies for minification.