google-closure-compiler 20250412.0.0-nightly → 20250413.0.0

package/README.md

@@ -84,7 +84,6 @@ The compiler package also includes build tool plugins for [Grunt](http://gruntjs
 
  * [Grunt Plugin](https://github.com/google/closure-compiler-npm/blob/master/packages/google-closure-compiler/docs/grunt.md)
  * [Gulp Plugin](https://github.com/google/closure-compiler-npm/blob/master/packages/google-closure-compiler/docs/gulp.md)
- * [Webpack Plugin](https://github.com/webpack-contrib/closure-webpack-plugin)
 
 ### Community Maintained Plugins
 Additionally, community members have created plugins leveraging this library.
@@ -97,36 +96,12 @@ Additionally, community members have created plugins leveraging this library.
 Override the path before first use.
 
 ```
-const Compiler = require('google-closure-compiler');
-
-Compiler.prototype.javaPath = '/node_modules/MODULE_NAME/jre/jre1.8.0_131.jre/Contents/Home/bin/java';
+import Compiler from 'google-closure-compiler';
 
 const compiler = new Compiler({args});
+compiler.javaPath = '/node_modules/MODULE_NAME/jre/jre1.8.0_131.jre/Contents/Home/bin/java';
 ```
 
-### Running the compiler using nailgun
-*Note: nailgun users are encouraged to try the native binary versions where available.*
-
-This gets around the long startup time of Google Closure Compiler using
-[Nailgun](https://github.com/facebook/nailgun), which runs a single java process in the background
-and keeps all of the classes loaded.
-
-First you need to install closure-gun by running the following command.
-```bash
-npm install closure-gun
-```
-
-Then point the package to use closure-gun rather than the JDK.
-
-```js
-const compilerPackage = require('google-closure-compiler');
-
-compilerPackage.compiler.JAR_PATH = undefined;
-compilerPackage.compiler.prototype.javaPath = './node_modules/.bin/closure-gun'
-```
-
-Note that when using gulp, Only invocations without gulp.src work with nailgun.
-
 ## Native Node Usage (for Plugin Authors)
 A low-level node class is included to facilitate spawning the compiler jar as a process from Node.
 In addition, it exposes a static property with the path to the compiler jar file.
@@ -134,10 +109,10 @@ In addition, it exposes a static property with the path to the compiler jar file
 ### Java Version
 
 ```js
-const ClosureCompiler = require('google-closure-compiler').compiler;
+import ClosureCompiler, {COMPILER_PATH, CONTRIB_PATH} from 'google-closure-compiler';
 
-console.log(ClosureCompiler.COMPILER_PATH); // absolute path to the compiler jar
-console.log(ClosureCompiler.CONTRIB_PATH); // absolute path to the contrib folder which contain externs
+console.log(COMPILER_PATH); // absolute path to the compiler jar
+console.log(CONTRIB_PATH); // absolute path to the contrib folder which contain externs
 
 const closureCompiler = new ClosureCompiler({
   js: 'file-one.js',

package/cli.js

@@ -14,9 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-'use strict';
-const {getNativeImagePath, getFirstSupportedPlatform} = require('./lib/utils');
-const parseArgs = require('minimist');
+import Compiler from './lib/node/index.js';
+import {getNativeImagePath, getFirstSupportedPlatform} from './lib/utils.js';
+import parseArgs from 'minimist';
 
 const compilerFlags = parseArgs(process.argv.slice(2));
 
@@ -59,7 +59,6 @@ Object.keys(compilerFlags).forEach((flag) => {
   }
 });
 
-const Compiler = require('./lib/node/closure-compiler');
 let args = process.argv.slice(2);
 for (let i = 0; i < args.length; i++) {
   if (/^--platform/.test(args[i])) {

package/externs/browser/decorators.js

@@ -0,0 +1,276 @@
+/*
+ * Copyright 2025 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Decorators for TypeScript classes.
+ * NOTE: generated by tsickle, then manually edited to fix type errors.
+ * Generated from: third_party/javascript/node_modules/typescript/stable/lib/lib.decorators.d.ts
+ *
+ * @externs
+ */
+
+/**
+ * @template Class
+ * @record
+ * @struct
+ */
+function ClassDecoratorContext() {}
+/** @const {string} */
+ClassDecoratorContext.prototype.kind;
+/** @const {(undefined|string)} */
+ClassDecoratorContext.prototype.name;
+/** @const {(undefined|?)} */
+ClassDecoratorContext.prototype.metadata;
+
+/**
+ * Adds a callback to be invoked after the class definition has been finalized.
+ *
+ * \@example
+ * ```ts
+ * function customElement(name: string): ClassDecoratorFunction {
+ *   return (target, context) => {
+ *     context.addInitializer(function () {
+ *       customElements.define(name, this);
+ *     });
+ *   }
+ * }
+ *
+ * \@customElement("my-element")
+ * class MyElement {}
+ * ```
+ * @public
+ * @param {function(this: (Class)): void} initializer
+ * @return {void}
+ */
+ClassDecoratorContext.prototype.addInitializer = function(initializer) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassMethodDecoratorContext() {}
+/** @const {string} */
+ClassMethodDecoratorContext.prototype.kind;
+/** @const {(string|symbol)} */
+ClassMethodDecoratorContext.prototype.name;
+/** @const {boolean} */
+ClassMethodDecoratorContext.prototype.static;
+/** @const {boolean} */
+ClassMethodDecoratorContext.prototype.private;
+/** @const {{has: function(This): boolean, get: function(This): Value}} */
+ClassMethodDecoratorContext.prototype.access;
+/** @const {(undefined|?)} */
+ClassMethodDecoratorContext.prototype.metadata;
+
+/**
+ * Adds a callback to be invoked either after static methods are defined but before
+ * static initializers are run (when decorating a `static` element), or before instance
+ * initializers are run (when decorating a non-`static` element).
+ *
+ * \@example
+ * ```ts
+ * const bound: ClassMethodDecoratorFunction = (value, context) {
+ *   if (context.private) throw new TypeError("Not supported on private methods.");
+ *   context.addInitializer(function () {
+ *     this[context.name] = this[context.name].bind(this);
+ *   });
+ * }
+ *
+ * class C {
+ *   message = "Hello";
+ *
+ * \@bound
+ *   m() {
+ *     console.log(this.message);
+ *   }
+ * }
+ * ```
+ * @public
+ * @param {function(this: (This)): void} initializer
+ * @return {void}
+ */
+ClassMethodDecoratorContext.prototype.addInitializer = function(initializer) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassGetterDecoratorContext() {}
+/** @const {string} */
+ClassGetterDecoratorContext.prototype.kind;
+/** @const {(string|symbol)} */
+ClassGetterDecoratorContext.prototype.name;
+/** @const {boolean} */
+ClassGetterDecoratorContext.prototype.static;
+/** @const {boolean} */
+ClassGetterDecoratorContext.prototype.private;
+/** @const {{has: function(This): boolean, get: function(This): Value}} */
+ClassGetterDecoratorContext.prototype.access;
+/** @const {(undefined|?)} */
+ClassGetterDecoratorContext.prototype.metadata;
+
+/**
+ * Adds a callback to be invoked either after static methods are defined but before
+ * static initializers are run (when decorating a `static` element), or before instance
+ * initializers are run (when decorating a non-`static` element).
+ * @public
+ * @param {function(this: (This)): void} initializer
+ * @return {void}
+ */
+ClassGetterDecoratorContext.prototype.addInitializer = function(initializer) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassSetterDecoratorContext() {}
+/** @const {string} */
+ClassSetterDecoratorContext.prototype.kind;
+/** @const {(string|symbol)} */
+ClassSetterDecoratorContext.prototype.name;
+/** @const {boolean} */
+ClassSetterDecoratorContext.prototype.static;
+/** @const {boolean} */
+ClassSetterDecoratorContext.prototype.private;
+/** @const {{has: function(This): boolean, set: function(This, Value): void}} */
+ClassSetterDecoratorContext.prototype.access;
+/** @const {(undefined|?)} */
+ClassSetterDecoratorContext.prototype.metadata;
+
+/**
+ * Adds a callback to be invoked either after static methods are defined but before
+ * static initializers are run (when decorating a `static` element), or before instance
+ * initializers are run (when decorating a non-`static` element).
+ * @public
+ * @param {function(this: (This)): void} initializer
+ * @return {void}
+ */
+ClassSetterDecoratorContext.prototype.addInitializer = function(initializer) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassAccessorDecoratorContext() {}
+/** @const {string} */
+ClassAccessorDecoratorContext.prototype.kind;
+/** @const {(string|symbol)} */
+ClassAccessorDecoratorContext.prototype.name;
+/** @const {boolean} */
+ClassAccessorDecoratorContext.prototype.static;
+/** @const {boolean} */
+ClassAccessorDecoratorContext.prototype.private;
+/** @const {{has: function(This): boolean, get: function(This): Value, set: function(This, Value): void}} */
+ClassAccessorDecoratorContext.prototype.access;
+/** @const {(undefined|?)} */
+ClassAccessorDecoratorContext.prototype.metadata;
+
+/**
+ * Adds a callback to be invoked immediately after the auto `accessor` being
+ * decorated is initialized (regardless if the `accessor` is `static` or not).
+ * @public
+ * @param {function(this: (This)): void} initializer
+ * @return {void}
+ */
+ClassAccessorDecoratorContext.prototype.addInitializer = function(initializer) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassAccessorDecoratorTarget() {}
+
+/**
+ * Invokes the getter that was defined prior to decorator application.
+ *
+ * \@example
+ * let value = target.get.call(instance);
+ * @public
+ * @this {This}
+ * @return {Value}
+ */
+ClassAccessorDecoratorTarget.prototype.get = function() {};
+
+/**
+ * Invokes the setter that was defined prior to decorator application.
+ *
+ * \@example
+ * target.set.call(instance, value);
+ * @public
+ * @this {This}
+ * @param {Value} value
+ * @return {void}
+ */
+ClassAccessorDecoratorTarget.prototype.set = function(value) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassAccessorDecoratorResult() {}
+
+/**
+ * An optional replacement getter function. If not provided, the existing getter function is used instead.
+ * @public
+ * @this {This}
+ * @return {Value}
+ */
+ClassAccessorDecoratorResult.prototype.get = function() {};
+
+/**
+ * An optional replacement setter function. If not provided, the existing setter function is used instead.
+ * @public
+ * @this {This}
+ * @param {Value} value
+ * @return {void}
+ */
+ClassAccessorDecoratorResult.prototype.set = function(value) {};
+
+/**
+ * An optional initializer mutator that is invoked when the underlying field initializer is evaluated.
+ * @public
+ * @this {This}
+ * @param {Value} value The incoming initializer value.
+ * @return {Value} The replacement initializer value.
+ */
+ClassAccessorDecoratorResult.prototype.init = function(value) {};
+/**
+ * @template This, Value
+ * @record
+ * @struct
+ */
+function ClassFieldDecoratorContext() {}
+/** @const {string} */
+ClassFieldDecoratorContext.prototype.kind;
+/** @const {(string|symbol)} */
+ClassFieldDecoratorContext.prototype.name;
+/** @const {boolean} */
+ClassFieldDecoratorContext.prototype.static;
+/** @const {boolean} */
+ClassFieldDecoratorContext.prototype.private;
+/** @const {{has: function(This): boolean, get: function(This): Value, set: function(This, Value): void}} */
+ClassFieldDecoratorContext.prototype.access;
+/** @const {(undefined|?)} */
+ClassFieldDecoratorContext.prototype.metadata;
+
+/**
+ * Adds a callback to be invoked immediately after the field being decorated
+ * is initialized (regardless if the field is `static` or not).
+ * @public
+ * @param {function(this: (This)): void} initializer
+ * @return {void}
+ */
+ClassFieldDecoratorContext.prototype.addInitializer = function(initializer) {};

package/externs/browser/deprecated.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2008 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview JavaScript Built-Ins that are not part of any specifications
+ * but are still needed in some project's build.
+ * @externs
+ */
+var opera = {};
+
+opera.postError;
+
+/** @nosideeffects */
+opera.version = function() {};
+
+/** @constructor */
+function XSLTProcessor() {}
+
+/**
+ * @param {Node} styleSheet
+ * @return {undefined}
+ * @deprecated
+ */
+XSLTProcessor.prototype.importStylesheet = function(styleSheet) {};
+
+/**
+ * @param {Node} source
+ * @return {Document}
+ * @deprecated
+ */
+XSLTProcessor.prototype.transformToDocument = function(source) {};
+
+/**
+ * @param {Node} source
+ * @param {Document} document
+ * @return {DocumentFragment}
+ * @deprecated
+ */
+XSLTProcessor.prototype.transformToFragment = function(source, document) {};
+
+// The "methods" object is a place to hang arbitrary external
+// properties. It is a throwback to pre-typed days, and should
+// not be used for any new definitions; it exists only to bridge
+// the gap between the old way and the new way.
+var methods = {};

package/externs/browser/es6_proxy.js

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2018 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for ECMAScript 6 Proxy objects.
+ * @see https://tc39.github.io/ecma262/#sec-proxy-objects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+ * @externs
+ */
+
+
+/**
+ * @record
+ * @template TARGET
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler
+ */
+function ProxyHandler() {}
+
+/**
+ * @type {(function(TARGET):?Object)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getPrototypeOf
+ */
+ProxyHandler.prototype.getPrototypeOf /* = function(target) {} */;
+
+/**
+ * @type {(function(TARGET, ?Object):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/setPrototypeOf
+ */
+ProxyHandler.prototype.setPrototypeOf /* = function(target, proto) {} */;
+
+/**
+ * @type {(function(TARGET):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-isextensible
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/isExtensible
+ */
+ProxyHandler.prototype.isExtensible /* = function(target) {} */;
+
+/**
+ * @type {(function(TARGET):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-preventextensions
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/preventExtensions
+ */
+ProxyHandler.prototype.preventExtensions /* = function(target) {} */;
+
+/**
+ * @type {(function(TARGET, (string|symbol)):(!ObjectPropertyDescriptor|undefined))|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor
+ */
+ProxyHandler.prototype.getOwnPropertyDescriptor /* = function(target, prop) {} */;
+
+/**
+ * @type {(function(TARGET, (string|symbol), !ObjectPropertyDescriptor):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/defineProperty
+ */
+ProxyHandler.prototype.defineProperty /* = function(target, prop, desc) {} */;
+
+/**
+ * @type {(function(TARGET, (string|symbol)):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-hasproperty-p
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/has
+ */
+ProxyHandler.prototype.has /* = function(target, prop) {} */;
+
+/**
+ * @type {(function(TARGET, (string|symbol), !Object):*)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get
+ */
+ProxyHandler.prototype.get /* = function(target, prop, receiver) {} */;
+
+/**
+ * @type {(function(TARGET, (string|symbol), *, !Object):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set
+ */
+ProxyHandler.prototype.set /* = function(target, prop, value, receiver) {} */;
+
+/**
+ * @type {(function(TARGET, (string|symbol)):boolean)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-delete-p
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/deleteProperty
+ */
+ProxyHandler.prototype.deleteProperty /* = function (target, prop) {} */;
+
+/**
+ * @type {(function(TARGET):!Array<(string|symbol)>)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/ownKeys
+ */
+ProxyHandler.prototype.ownKeys /* = function(target) {} */;
+
+/**
+ * @type {(function(TARGET, *, !Array):*)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply
+ */
+ProxyHandler.prototype.apply /* = function(target, thisArg, argList) {} */;
+
+/**
+ * @type {(function(TARGET, !Array, function(new: ?, ...?)):!Object)|undefined}
+ * @see https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct
+ */
+ProxyHandler.prototype.construct /* = function(target, argList, newTarget) {} */;
+
+
+/**
+ * @constructor
+ * @param {TARGET} target
+ * @param {!ProxyHandler<TARGET>} handler
+ * @template TARGET
+ * @see https://tc39.github.io/ecma262/#sec-proxy-constructor
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#Syntax
+ */
+function Proxy(target, handler) {}
+
+/**
+ * @param {TARGET} target
+ * @param {!ProxyHandler<TARGET>} handler
+ * @return {{proxy: !Proxy<TARGET>, revoke: function():void}}
+ * @template TARGET
+ * @see https://tc39.github.io/ecma262/#sec-proxy.revocable
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/revocable
+ */
+Proxy.revocable = function(target, handler) {};