// Deleting all bundles from this object prevents them from being written,

// see https://rollupjs.org/guide/en/#generatebundle.

for (const name in bundles) {

delete bundles[name];

}

context,

nameCache,

classPropertyPrefix,

testPropertyPrefix

) => {

// Only prefix class properties once per options context, as a perf optimization

if (nameCache && !addedClassPrefix.has(context)) {

const {

props: {props},

} = nameCache;

classPropertyPrefix = testPropertyPrefix + classPropertyPrefix;

for (const p in props) {

// Note all properties in the terser name cache are prefixed with '$'

// (presumably to avoid collisions with built-ins). Checking for the

// prefix is just to ensure we don't double-prefix properties if

// `prefixClassProperties` is called twice on the same `nameCache`.

if (p.startsWith('$__') && !props[p].startsWith(classPropertyPrefix)) {

props[p] = classPropertyPrefix + props[p];

} else if (testPropertyPrefix && !(p.slice(1) in stableProperties)) {

// Only change the names of non-stable properties when testing

props[p] = testPropertyPrefix + props[p];

}

}

addedClassPrefix.add(context);

}

return nameCache;

nameCache,

classPropertyPrefix = '',

testPropertyPrefix = ''

) => ({

warnings: true,

ecma: 2021,

compress: {

unsafe: true,

// An extra pass can squeeze out an extra byte or two.

passes: 2,

},

output: {

// "some" preserves @license and @preserve comments

comments: CHECKSIZE ? false : 'some',

inline_script: false,

},

// This is implemented as a getter, so that we apply the class property prefix

// after the `nameCacheSeeder` build runs

get nameCache() {

return prefixProperties(

this,

nameCache,

classPropertyPrefix,

testPropertyPrefix

);

},

mangle: {

properties: {

regex: /^_/,

reserved: reservedProperties,

// Set to true to mangle to readable names

debug: false,

},

},

entryPoints,

external = [],

bundled = [],

testPropertyPrefix,

packageName,

outputDir = './',

copyHtmlTests = true,

includeNodeBuild = false,

// eslint-disable-next-line no-undef

} = options) {

const classPropertyPrefix = PACKAGE_CLASS_PREFIXES[packageName];

if (classPropertyPrefix === undefined) {

throw new Error(

`Package ${packageName} was being built using 'litProdConfig' ` +

`but does not have a PACKAGE_CLASS_PREFIXES mapping in rollup-common.js.`

);

}

// The Terser shared name cache allows us to mangle the names of properties

// consistently across modules, so that e.g. directive-helpers.js can safely

// access internal details of lit-html.js.

//

// However, we still have to account for the problem of mangled names getting

// re-used for different properties across files, because Terser does not

// consult the nameCache to decide whether a mangled name is available or not.

//

// For example:

//

// file1:

// obj.foo -> A

// obj.bar -> B

//

// file2:

// obj.bar -> B (Correctly chosen from nameCache.)

// obj.baz -> A (Oops, foo and baz are different properties on the same

// object, but now they both have the same mangled name,

// which could result in very unpredictable behavior).

//

// To trick Terser into doing what we need here, we first create a giant bundle

// of all our code in a single file, tell Terser to minify that, and then throw

// it away. This seeds the name cache in a way that guarantees every property

// gets a unique mangled name.

const nameCache = {

props: {

// Note all properties in the terser name cache are prefixed with '$'

// (presumably to avoid collisions with built-ins).

props: Object.entries(stableProperties).reduce(

(obj, [name, val]) => ({

...obj,

['$' + name]: STABLE_PROPERTY_PREFIX + val,

}),

{}

),

},

};

const nameCacheSeederInfile = 'name-cache-seeder-virtual-input.js';

const nameCacheSeederOutfile = 'name-cache-seeder-throwaway-output.js';

const nameCacheSeederContents = [

// Import every entry point so that we see all property accesses.

// Give a unique named import to prevent duplicate identifier errors.

...entryPoints.map(

(name, idx) => `import * as import${idx} from './development/${name}.js';`

),

// Prevent tree shaking that occurs during mangling.

...entryPoints.map((_name, idx) => `console.log(import${idx});`),

// Synthesize a property access for all cross-package mangled property names

// so that even if we don't access a property in this package, we will still

// reserve other properties from re-using that name.

...Object.keys(stableProperties).map(

(name) => `console.log(window.${name});`

),

].join('\n');

const nameCacheSeederTerserOptions = generateTerserOptions(nameCache);

const terserOptions = generateTerserOptions(

nameCache,

classPropertyPrefix,

testPropertyPrefix

);

return [

{

input: nameCacheSeederInfile,

output: {

file: nameCacheSeederOutfile,

format: 'esm',

},

external,

// Since our virtual name cache seeder module doesn't export anything,

// almost everything gets tree shaken out, and terser wouldn't see any

// properties.

treeshake: false,

plugins: [

virtual({

[nameCacheSeederInfile]: nameCacheSeederContents,

}),

terser(nameCacheSeederTerserOptions),

skipBundleOutput,

],

},

// Production build

{

input: entryPoints.map((name) => `development/${name}.js`),

output: {

dir: outputDir,

format: 'esm',

// Preserve existing module structure (e.g. preserve the "directives/"

// directory).

preserveModules: true,

sourcemap: !CHECKSIZE,

},

external,

plugins: [

// Switch all DEV_MODE variable assignment values to false. Terser's dead

// code removal will then remove any blocks that are conditioned on this

// variable.

//

// Code in our development/ directory looks like this:

//

// const DEV_MODE = true;

// if (DEV_MODE) { // dev mode stuff }

//

// Note we want the transformation to `goog.define` syntax for Closure

// Compiler to be trivial, and that would look something like this:

//

// const DEV_MODE = goog.define('lit-html.DEV_MODE', false);

//

// We can't use terser's compress.global_defs option, because it won't

// replace the value of a variable that is already defined in scope (see

// https://github.com/terser/terser#conditional-compilation). It seems to be

// designed assuming that you are _always_ using terser to set the def one

// way or another, so it's difficult to define a default in the source code

// itself.

replace({

preventAssignment: true,

values: {

'const DEV_MODE = true': 'const DEV_MODE = false',

'const ENABLE_EXTRA_SECURITY_HOOKS = true':

'const ENABLE_EXTRA_SECURITY_HOOKS = false',

'const ENABLE_SHADYDOM_NOPATCH = true':

'const ENABLE_SHADYDOM_NOPATCH = false',

},

}),

// This plugin automatically composes the existing TypeScript -> raw JS

// sourcemap with the raw JS -> minified JS one that we're generating here.

sourcemaps(),

terser(terserOptions),

summary({

showBrotliSize: true,

showGzippedSize: true,

}),

...(CHECKSIZE ? [skipBundleOutput] : []),

...(copyHtmlTests && !CHECKSIZE

? [

// Copy polyfill support tests.

copy({

targets: [

{

src: `src/test/*_test.html`,

dest: ['development/test/', 'test/'],

},

{

// TODO: use flatten: false when this is fixed

// https://github.com/vladshcherbin/rollup-plugin-copy/issues/37

src: `src/test/polyfill-support/*_test.html`,

dest: [

'development/test/polyfill-support',

'test/polyfill-support',

],

},

],

}),

]

: []),

],

},

// Node build

...(includeNodeBuild

? [

{

input: entryPoints.map((name) => `development/${name}.js`),

output: {

dir: `${outputDir}/node`,

format: 'esm',

preserveModules: true,

sourcemap: !CHECKSIZE,

},

external,

plugins: [

replace({

preventAssignment: true,

values: {

// Setting NODE_MODE to true enables node-specific behaviors,

// i.e. using globalThis instead of window, and shimming APIs

// needed for Lit bootup.

'const NODE_MODE = false': 'const NODE_MODE = true',

// Other variables should behave like prod mode.

'const DEV_MODE = true': 'const DEV_MODE = false',

'const ENABLE_EXTRA_SECURITY_HOOKS = true':

'const ENABLE_EXTRA_SECURITY_HOOKS = false',

'const ENABLE_SHADYDOM_NOPATCH = true':

'const ENABLE_SHADYDOM_NOPATCH = false',

},

}),

...injectNodeDomShimIntoReactiveElement,

sourcemaps(),

// We want the production Node build to be minified because:

//

// 1. It should be very slightly faster, even in Node where bytes

// are not as important as in the browser.

//

// 2. It means we don't need a Node build for lit-element. There

// is no Node-specific logic needed in lit-element. However,

// lit-element and reactive-element must be consistently

// minified or unminified together, because lit-element

// references properties from reactive-element which will

// otherwise have different names. The default export that

// lit-element will use is minified.

terser(terserOptions),

summary({

showBrotliSize: true,

showGzippedSize: true,

}),

...(CHECKSIZE ? [skipBundleOutput] : []),

],

},

{

// Also create a development Node build that does not minify to be

// used during development so it can work along side the unminified

// dev build of lit-element

input: entryPoints.map((name) => `development/${name}.js`),

output: {

dir: `${outputDir}/node/development`,

format: 'esm',

preserveModules: true,

sourcemap: !CHECKSIZE,

},

external,

plugins: [

replace({

preventAssignment: true,

values: {

// Setting NODE_MODE to true enables node-specific behaviors,

// i.e. using globalThis instead of window, and shimming APIs

// needed for Lit bootup.

'const NODE_MODE = false': 'const NODE_MODE = true',

'const ENABLE_SHADYDOM_NOPATCH = true':

'const ENABLE_SHADYDOM_NOPATCH = false',

},

}),

...injectNodeDomShimIntoReactiveElement,

sourcemaps(),

summary({

showBrotliSize: true,

showGzippedSize: true,

}),

...(CHECKSIZE ? [skipBundleOutput] : []),

],

},

]

: []),

// CDN bundles

...bundled.map(({file, output, name, format, sourcemapPathTransform}) =>

litMonoBundleConfig({

file,

output,

name,

terserOptions,

format,

sourcemapPathTransform,

})

),

];

file,

output,

name,

terserOptions,

format = 'umd',

sourcemapPathTransform,

// eslint-disable-next-line no-undef

} = options) => ({

input: `development/${file}.js`,

output: {

file: `${output || file}.js`,

format,

name,

sourcemap: !CHECKSIZE,

sourcemapPathTransform,

},

plugins: [

nodeResolve({

// We want to resolve to development, because the default is production,

// which is already rolled-up sources. That creates an unnecessary

// dependency between rollup build steps, and causes double-minification.

exportConditions: ['development'],

}),

replace({

preventAssignment: false,

values: {

'const DEV_MODE = true': 'const DEV_MODE = false',

'const ENABLE_EXTRA_SECURITY_HOOKS = true':

'const ENABLE_EXTRA_SECURITY_HOOKS = false',

'const ENABLE_SHADYDOM_NOPATCH = true':

'const ENABLE_SHADYDOM_NOPATCH = false',

// For downleveled ES5 build of polyfill-support

'var DEV_MODE = true': 'var DEV_MODE = false',

'var ENABLE_EXTRA_SECURITY_HOOKS = true':

'var ENABLE_EXTRA_SECURITY_HOOKS = false',

'var ENABLE_SHADYDOM_NOPATCH = true':

'var ENABLE_SHADYDOM_NOPATCH = false',

},

}),

// This plugin automatically composes the existing TypeScript -> raw JS

// sourcemap with the raw JS -> minified JS one that we're generating here.

sourcemaps(),

terser(terserOptions),

summary({

showBrotliSize: true,

showGzippedSize: true,

}),

],