@rushstack/module-minifier 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+@rushstack/module-minifier
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# @rushstack/module-minifier
+
+This library wraps terser in convenient handles for parallelization. It powers @rushstack/module-minifier-plugin but has no coupling with webpack.
+
+## Links
+
+- [CHANGELOG.md](
+  https://github.com/microsoft/rushstack/blob/main/libraries/module-minifier/CHANGELOG.md) - Find
+  out what's new in the latest version
+- [API Reference](https://rushstack.io/pages/api/module-minifier/)
+
+`@rushstack/module-minifier` is part of the [Rush Stack](https://rushstack.io/) family of projects.

package/dist/module-minifier.d.ts

@@ -0,0 +1,250 @@
+/// <reference types="node" />
+
+import { MessagePort } from 'worker_threads';
+import { MinifyOptions } from 'terser';
+import type { RawSourceMap } from 'source-map';
+
+/**
+ * Gets a base54 string suitable for use as a JavaScript identifier, omitting those that are valid ECMAScript keywords
+ *
+ * @param ordinal - The number to convert to a base54 identifier
+ *
+ * @public
+ */
+export declare function getIdentifier(ordinal: number): string;
+
+/**
+ * Options for configuring the LocalMinifier
+ * @public
+ */
+export declare interface ILocalMinifierOptions {
+    terserOptions?: MinifyOptions;
+}
+
+/**
+ * Metadata from the minifier for the plugin
+ * @public
+ */
+export declare interface IMinifierConnection {
+    /**
+     * Hash of the configuration of this minifier, for cache busting.
+     */
+    configHash: string;
+    /**
+     * Callback to be invoked when done with the minifier
+     */
+    disconnect(): Promise<void>;
+}
+
+/**
+ * Callback passed to a minifier function
+ * @public
+ */
+export declare interface IModuleMinificationCallback {
+    (result: IModuleMinificationResult): void;
+}
+
+/**
+ * Result from the minifier function when an error is encountered.
+ * @public
+ */
+export declare interface IModuleMinificationErrorResult {
+    /**
+     * Identity of the request
+     */
+    hash: string;
+    /**
+     * The error encountered, to be added to the current compilation's error collection.
+     */
+    error: Error;
+    /**
+     * Marker property to always return the same result shape.
+     */
+    code?: undefined;
+    /**
+     * Marker property to always return the same result shape.
+     */
+    map?: undefined;
+}
+
+/**
+ * Request to the minifier
+ * @public
+ */
+export declare interface IModuleMinificationRequest {
+    /**
+     * Identity of the request. Will be included in the response.
+     */
+    hash: string;
+    /**
+     * The raw code fragment
+     */
+    code: string;
+    /**
+     * File name to show for the source code in the source map
+     */
+    nameForMap: string | undefined;
+    /**
+     * Reserved variable names, e.g. __WEBPACK_EXTERNAL_MODULE_1__
+     */
+    externals: string[] | undefined;
+}
+
+/**
+ * Result from the minifier.
+ * @public
+ */
+export declare type IModuleMinificationResult = IModuleMinificationErrorResult | IModuleMinificationSuccessResult;
+
+/**
+ * Result from the minifier on a successful minification.
+ * @public
+ */
+export declare interface IModuleMinificationSuccessResult {
+    /**
+     * Identity of the request
+     */
+    hash: string;
+    /**
+     * The error property being `undefined` indicates success.
+     */
+    error: undefined;
+    /**
+     * The minified code.
+     */
+    code: string;
+    /**
+     * Marker property to always return the same result shape.
+     */
+    map?: RawSourceMap;
+}
+
+/**
+ * Object that can be invoked to minify code.
+ * @public
+ */
+export declare interface IModuleMinifier {
+    /**
+     * Asynchronously minify a module
+     */
+    minify: IModuleMinifierFunction;
+    /**
+     * Prevents the minifier from shutting down until the returned `disconnect()` callback is invoked.
+     * The callback may be used to surface errors encountered by the minifier that may not be relevant to a specific file.
+     * It should be called to allow the minifier to cleanup
+     */
+    connect(): Promise<IMinifierConnection>;
+}
+
+/**
+ * An async function called to minify a chunk of code
+ * @public
+ */
+export declare interface IModuleMinifierFunction {
+    (request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+}
+
+/**
+ * Options for configuring the WorkerPoolMinifier
+ * @public
+ */
+export declare interface IWorkerPoolMinifierOptions {
+    /**
+     * Maximum number of worker threads to use. Will never use more than there are modules to process.
+     * Defaults to os.cpus().length
+     */
+    maxThreads?: number;
+    /**
+     * The options to forward to Terser.
+     * `output.comments` is currently not configurable and will always extract license comments to a separate file.
+     */
+    terserOptions?: MinifyOptions;
+    /**
+     * If true, log to the console about the minification results.
+     */
+    verbose?: boolean;
+}
+
+/**
+ * Minifier implementation that minifies code on the main thread.
+ * @public
+ */
+export declare class LocalMinifier implements IModuleMinifier {
+    private readonly _terserOptions;
+    private readonly _resultCache;
+    private readonly _configHash;
+    constructor(options: ILocalMinifierOptions);
+    /**
+     * Transform that invokes Terser on the main thread
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+    connect(): Promise<IMinifierConnection>;
+}
+
+/**
+ * Minifier implementation that outsources requests to the other side of a MessagePort
+ * @public
+ */
+export declare class MessagePortMinifier implements IModuleMinifier {
+    readonly port: MessagePort;
+    private readonly _callbacks;
+    constructor(port: MessagePort);
+    /**
+     * No-op code transform.
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+    connect(): Promise<IMinifierConnection>;
+}
+
+export { MinifyOptions }
+
+/**
+ * Minifies a single chunk of code. Factored out for reuse between WorkerPoolMinifier and LocalMinifier
+ * @internal
+ */
+export declare function _minifySingleFileAsync(request: IModuleMinificationRequest, terserOptions: MinifyOptions): Promise<IModuleMinificationResult>;
+
+/**
+ * Minifier implementation that does not actually transform the code, for debugging.
+ * @public
+ */
+export declare class NoopMinifier implements IModuleMinifier {
+    /**
+     * No-op code transform.
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+    connect(): Promise<IMinifierConnection>;
+}
+
+/**
+ * Minifier implementation that uses a thread pool for minification.
+ * @public
+ */
+export declare class WorkerPoolMinifier implements IModuleMinifier {
+    private readonly _pool;
+    private readonly _verbose;
+    private readonly _configHash;
+    private _refCount;
+    private _deduped;
+    private _minified;
+    private readonly _resultCache;
+    private readonly _activeRequests;
+    constructor(options: IWorkerPoolMinifierOptions);
+    get maxThreads(): number;
+    set maxThreads(threads: number);
+    /**
+     * Transform code by farming it out to a worker pool.
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+    connect(): Promise<IMinifierConnection>;
+}
+
+export { }

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.24.1"
+    }
+  ]
+}

package/lib/LocalMinifier.d.ts

@@ -0,0 +1,27 @@
+import type { MinifyOptions } from 'terser';
+import type { IMinifierConnection, IModuleMinificationCallback, IModuleMinificationRequest, IModuleMinifier } from './types';
+/**
+ * Options for configuring the LocalMinifier
+ * @public
+ */
+export interface ILocalMinifierOptions {
+    terserOptions?: MinifyOptions;
+}
+/**
+ * Minifier implementation that minifies code on the main thread.
+ * @public
+ */
+export declare class LocalMinifier implements IModuleMinifier {
+    private readonly _terserOptions;
+    private readonly _resultCache;
+    private readonly _configHash;
+    constructor(options: ILocalMinifierOptions);
+    /**
+     * Transform that invokes Terser on the main thread
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+    connect(): Promise<IMinifierConnection>;
+}
+//# sourceMappingURL=LocalMinifier.d.ts.map

package/lib/LocalMinifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalMinifier.d.ts","sourceRoot":"","sources":["../src/LocalMinifier.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,KAAK,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,EAE1B,eAAe,EAChB,MAAM,SAAS,CAAC;AAGjB;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,aAAc,YAAW,eAAe;IACnD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAE/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyC;IACtE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAElB,OAAO,EAAE,qBAAqB;IAoBjD;;;;OAIG;IACI,MAAM,CAAC,OAAO,EAAE,0BAA0B,EAAE,QAAQ,EAAE,2BAA2B,GAAG,IAAI;IAwBlF,OAAO,IAAI,OAAO,CAAC,mBAAmB,CAAC;CAQrD"}

package/lib/LocalMinifier.js

@@ -0,0 +1,69 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalMinifier = void 0;
+const crypto_1 = require("crypto");
+const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
+const MinifySingleFile_1 = require("./MinifySingleFile");
+/**
+ * Minifier implementation that minifies code on the main thread.
+ * @public
+ */
+class LocalMinifier {
+    constructor(options) {
+        const { terserOptions = {} } = options || {};
+        this._terserOptions = {
+            ...terserOptions,
+            output: terserOptions.output
+                ? {
+                    ...terserOptions.output
+                }
+                : {}
+        };
+        this._configHash = (0, crypto_1.createHash)('sha256')
+            .update(LocalMinifier.name, 'utf8')
+            .update((0, serialize_javascript_1.default)(terserOptions))
+            .digest('base64');
+        this._resultCache = new Map();
+    }
+    /**
+     * Transform that invokes Terser on the main thread
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request, callback) {
+        const { hash } = request;
+        const cached = this._resultCache.get(hash);
+        if (cached) {
+            return callback(cached);
+        }
+        (0, MinifySingleFile_1.minifySingleFileAsync)(request, this._terserOptions)
+            .then((result) => {
+            this._resultCache.set(hash, result);
+            callback(result);
+        })
+            .catch((error) => {
+            // This branch is here to satisfy the no-floating-promises lint rule
+            callback({
+                error: error,
+                code: undefined,
+                map: undefined,
+                hash
+            });
+        });
+    }
+    async connect() {
+        return {
+            configHash: this._configHash,
+            disconnect: async () => {
+                // Do nothing.
+            }
+        };
+    }
+}
+exports.LocalMinifier = LocalMinifier;
+//# sourceMappingURL=LocalMinifier.js.map

package/lib/LocalMinifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalMinifier.js","sourceRoot":"","sources":["../src/LocalMinifier.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;;;;AAE3D,mCAAoC;AACpC,gFAA6C;AAU7C,yDAA2D;AAU3D;;;GAGG;AACH,MAAa,aAAa;IAMxB,YAAmB,OAA8B;QAC/C,MAAM,EAAE,aAAa,GAAG,EAAE,EAAE,GAAG,OAAO,IAAI,EAAE,CAAC;QAE7C,IAAI,CAAC,cAAc,GAAG;YACpB,GAAG,aAAa;YAChB,MAAM,EAAE,aAAa,CAAC,MAAM;gBAC1B,CAAC,CAAC;oBACE,GAAG,aAAa,CAAC,MAAM;iBACxB;gBACH,CAAC,CAAC,EAAE;SACP,CAAC;QAEF,IAAI,CAAC,WAAW,GAAG,IAAA,mBAAU,EAAC,QAAQ,CAAC;aACpC,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC;aAClC,MAAM,CAAC,IAAA,8BAAS,EAAC,aAAa,CAAC,CAAC;aAChC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEpB,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAAE,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,OAAmC,EAAE,QAAqC;QACtF,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;QAEzB,MAAM,MAAM,GAA0C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClF,IAAI,MAAM,EAAE;YACV,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;SACzB;QAED,IAAA,wCAAqB,EAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC;aAChD,IAAI,CAAC,CAAC,MAAiC,EAAE,EAAE;YAC1C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACpC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACnB,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACf,oEAAoE;YACpE,QAAQ,CAAC;gBACP,KAAK,EAAE,KAAc;gBACrB,IAAI,EAAE,SAAS;gBACf,GAAG,EAAE,SAAS;gBACd,IAAI;aACL,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,WAAW;YAC5B,UAAU,EAAE,KAAK,IAAI,EAAE;gBACrB,cAAc;YAChB,CAAC;SACF,CAAC;IACJ,CAAC;CACF;AA/DD,sCA+DC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { createHash } from 'crypto';\nimport serialize from 'serialize-javascript';\nimport type { MinifyOptions } from 'terser';\n\nimport type {\n  IMinifierConnection,\n  IModuleMinificationCallback,\n  IModuleMinificationRequest,\n  IModuleMinificationResult,\n  IModuleMinifier\n} from './types';\nimport { minifySingleFileAsync } from './MinifySingleFile';\n\n/**\n * Options for configuring the LocalMinifier\n * @public\n */\nexport interface ILocalMinifierOptions {\n  terserOptions?: MinifyOptions;\n}\n\n/**\n * Minifier implementation that minifies code on the main thread.\n * @public\n */\nexport class LocalMinifier implements IModuleMinifier {\n  private readonly _terserOptions: MinifyOptions;\n\n  private readonly _resultCache: Map<string, IModuleMinificationResult>;\n  private readonly _configHash: string;\n\n  public constructor(options: ILocalMinifierOptions) {\n    const { terserOptions = {} } = options || {};\n\n    this._terserOptions = {\n      ...terserOptions,\n      output: terserOptions.output\n        ? {\n            ...terserOptions.output\n          }\n        : {}\n    };\n\n    this._configHash = createHash('sha256')\n      .update(LocalMinifier.name, 'utf8')\n      .update(serialize(terserOptions))\n      .digest('base64');\n\n    this._resultCache = new Map();\n  }\n\n  /**\n   * Transform that invokes Terser on the main thread\n   * @param request - The request to process\n   * @param callback - The callback to invoke\n   */\n  public minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void {\n    const { hash } = request;\n\n    const cached: IModuleMinificationResult | undefined = this._resultCache.get(hash);\n    if (cached) {\n      return callback(cached);\n    }\n\n    minifySingleFileAsync(request, this._terserOptions)\n      .then((result: IModuleMinificationResult) => {\n        this._resultCache.set(hash, result);\n        callback(result);\n      })\n      .catch((error) => {\n        // This branch is here to satisfy the no-floating-promises lint rule\n        callback({\n          error: error as Error,\n          code: undefined,\n          map: undefined,\n          hash\n        });\n      });\n  }\n\n  public async connect(): Promise<IMinifierConnection> {\n    return {\n      configHash: this._configHash,\n      disconnect: async () => {\n        // Do nothing.\n      }\n    };\n  }\n}\n"]}

package/lib/MessagePortMinifier.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { MessagePort } from 'worker_threads';
+import type { IMinifierConnection, IModuleMinificationCallback, IModuleMinificationRequest, IModuleMinifier } from './types';
+/**
+ * Minifier implementation that outsources requests to the other side of a MessagePort
+ * @public
+ */
+export declare class MessagePortMinifier implements IModuleMinifier {
+    readonly port: MessagePort;
+    private readonly _callbacks;
+    constructor(port: MessagePort);
+    /**
+     * No-op code transform.
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void;
+    connect(): Promise<IMinifierConnection>;
+}
+//# sourceMappingURL=MessagePortMinifier.d.ts.map

package/lib/MessagePortMinifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePortMinifier.d.ts","sourceRoot":"","sources":["../src/MessagePortMinifier.ts"],"names":[],"mappings":";AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,EAE1B,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,eAAe;IACzD,SAAgB,IAAI,EAAE,WAAW,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6C;gBAErD,IAAI,EAAE,WAAW;IAKpC;;;;OAIG;IACI,MAAM,CAAC,OAAO,EAAE,0BAA0B,EAAE,QAAQ,EAAE,2BAA2B,GAAG,IAAI;IAclF,OAAO,IAAI,OAAO,CAAC,mBAAmB,CAAC;CA0BrD"}

package/lib/MessagePortMinifier.js

@@ -0,0 +1,56 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagePortMinifier = void 0;
+const events_1 = require("events");
+/**
+ * Minifier implementation that outsources requests to the other side of a MessagePort
+ * @public
+ */
+class MessagePortMinifier {
+    constructor(port) {
+        this.port = port;
+        this._callbacks = new Map();
+    }
+    /**
+     * No-op code transform.
+     * @param request - The request to process
+     * @param callback - The callback to invoke
+     */
+    minify(request, callback) {
+        const { hash } = request;
+        const callbacks = this._callbacks.get(hash);
+        if (callbacks) {
+            callbacks.push(callback);
+            return;
+        }
+        this._callbacks.set(hash, [callback]);
+        this.port.postMessage(request);
+    }
+    async connect() {
+        const configHashPromise = (0, events_1.once)(this.port, 'message');
+        this.port.postMessage('initialize');
+        const configHash = await configHashPromise;
+        const callbacks = this._callbacks;
+        function handler(message) {
+            if (typeof message === 'object') {
+                const callbacksForRequest = callbacks.get(message.hash);
+                callbacks.delete(message.hash);
+                for (const callback of callbacksForRequest) {
+                    callback(message);
+                }
+            }
+        }
+        this.port.on('message', handler);
+        return {
+            configHash,
+            disconnect: async () => {
+                this.port.off('message', handler);
+                this.port.close();
+            }
+        };
+    }
+}
+exports.MessagePortMinifier = MessagePortMinifier;
+//# sourceMappingURL=MessagePortMinifier.js.map

package/lib/MessagePortMinifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePortMinifier.js","sourceRoot":"","sources":["../src/MessagePortMinifier.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,mCAA8B;AAW9B;;;GAGG;AACH,MAAa,mBAAmB;IAK9B,YAAmB,IAAiB;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,OAAmC,EAAE,QAAqC;QACtF,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;QAEzB,MAAM,SAAS,GAA8C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvF,IAAI,SAAS,EAAE;YACb,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzB,OAAO;SACR;QAED,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QAEtC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,MAAM,iBAAiB,GAAoB,IAAA,aAAI,EAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAA+B,CAAC;QACpG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;QACpC,MAAM,UAAU,GAAW,MAAM,iBAAiB,CAAC;QAEnD,MAAM,SAAS,GAA+C,IAAI,CAAC,UAAU,CAAC;QAE9E,SAAS,OAAO,CAAC,OAAmD;YAClE,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC/B,MAAM,mBAAmB,GAAkC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAE,CAAC;gBACxF,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC/B,KAAK,MAAM,QAAQ,IAAI,mBAAmB,EAAE;oBAC1C,QAAQ,CAAC,OAAO,CAAC,CAAC;iBACnB;aACF;QACH,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACjC,OAAO;YACL,UAAU;YACV,UAAU,EAAE,KAAK,IAAI,EAAE;gBACrB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAClC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YACpB,CAAC;SACF,CAAC;IACJ,CAAC;CACF;AAvDD,kDAuDC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { once } from 'events';\nimport { MessagePort } from 'worker_threads';\n\nimport type {\n  IMinifierConnection,\n  IModuleMinificationCallback,\n  IModuleMinificationRequest,\n  IModuleMinificationResult,\n  IModuleMinifier\n} from './types';\n\n/**\n * Minifier implementation that outsources requests to the other side of a MessagePort\n * @public\n */\nexport class MessagePortMinifier implements IModuleMinifier {\n  public readonly port: MessagePort;\n\n  private readonly _callbacks: Map<string, IModuleMinificationCallback[]>;\n\n  public constructor(port: MessagePort) {\n    this.port = port;\n    this._callbacks = new Map();\n  }\n\n  /**\n   * No-op code transform.\n   * @param request - The request to process\n   * @param callback - The callback to invoke\n   */\n  public minify(request: IModuleMinificationRequest, callback: IModuleMinificationCallback): void {\n    const { hash } = request;\n\n    const callbacks: IModuleMinificationCallback[] | undefined = this._callbacks.get(hash);\n    if (callbacks) {\n      callbacks.push(callback);\n      return;\n    }\n\n    this._callbacks.set(hash, [callback]);\n\n    this.port.postMessage(request);\n  }\n\n  public async connect(): Promise<IMinifierConnection> {\n    const configHashPromise: Promise<string> = once(this.port, 'message') as unknown as Promise<string>;\n    this.port.postMessage('initialize');\n    const configHash: string = await configHashPromise;\n\n    const callbacks: Map<string, IModuleMinificationCallback[]> = this._callbacks;\n\n    function handler(message: IModuleMinificationResult | number | false): void {\n      if (typeof message === 'object') {\n        const callbacksForRequest: IModuleMinificationCallback[] = callbacks.get(message.hash)!;\n        callbacks.delete(message.hash);\n        for (const callback of callbacksForRequest) {\n          callback(message);\n        }\n      }\n    }\n\n    this.port.on('message', handler);\n    return {\n      configHash,\n      disconnect: async () => {\n        this.port.off('message', handler);\n        this.port.close();\n      }\n    };\n  }\n}\n"]}

package/lib/MinifiedIdentifier.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Gets a base54 string suitable for use as a JavaScript identifier, not accounting for reserved keywords
+ * @param ordinal - The number to convert to a base54 identifier
+ */
+export declare function getIdentifierInternal(ordinal: number): string;
+/**
+ * Converts an identifier into the ordinal that would produce it, not accounting for reserved keywords
+ * Returns NaN if the result would exceed 31 bits
+ * @param identifier - The identifier to convert to a numeric value
+ */
+export declare function getOrdinalFromIdentifierInternal(identifier: string): number;
+/**
+ * Gets a base54 string suitable for use as a JavaScript identifier, omitting those that are valid ECMAScript keywords
+ *
+ * @param ordinal - The number to convert to a base54 identifier
+ *
+ * @public
+ */
+export declare function getIdentifier(ordinal: number): string;
+//# sourceMappingURL=MinifiedIdentifier.d.ts.map

package/lib/MinifiedIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinifiedIdentifier.d.ts","sourceRoot":"","sources":["../src/MinifiedIdentifier.ts"],"names":[],"mappings":"AA0EA;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAW7D;AAYD;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAmB3E;AAgBD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAWrD"}

package/lib/MinifiedIdentifier.js

@@ -0,0 +1,148 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdentifier = exports.getOrdinalFromIdentifierInternal = exports.getIdentifierInternal = void 0;
+// TODO: Allow dynamic override of these values in the input to the minifier
+const constants_1 = require("./constants");
+// Set of ECMAScript reserved keywords (past and present): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar
+const RESERVED_KEYWORDS = [
+    'abstract',
+    'arguments',
+    'boolean',
+    'break',
+    'byte',
+    'case',
+    'catch',
+    'char',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'double',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'final',
+    'finally',
+    'float',
+    'for',
+    'function',
+    'get',
+    'goto',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'int',
+    'interface',
+    'let',
+    'long',
+    'native',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'set',
+    'short',
+    'static',
+    'super',
+    'switch',
+    'synchronized',
+    'this',
+    'throw',
+    'throws',
+    'transient',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'volatile',
+    'while',
+    'with',
+    'yield'
+];
+/**
+ * Gets a base54 string suitable for use as a JavaScript identifier, not accounting for reserved keywords
+ * @param ordinal - The number to convert to a base54 identifier
+ */
+function getIdentifierInternal(ordinal) {
+    let ret = constants_1.IDENTIFIER_LEADING_DIGITS[ordinal % 54];
+    ordinal = (ordinal / 54) | 0; // eslint-disable-line no-bitwise
+    while (ordinal > 0) {
+        --ordinal;
+        ret += constants_1.IDENTIFIER_TRAILING_DIGITS[ordinal & 0x3f]; // eslint-disable-line no-bitwise
+        ordinal >>>= 6; // eslint-disable-line no-bitwise
+    }
+    return ret;
+}
+exports.getIdentifierInternal = getIdentifierInternal;
+const leadingCharIndex = new Map();
+for (let i = 0; i < 64; i++) {
+    leadingCharIndex.set(constants_1.IDENTIFIER_LEADING_DIGITS.charCodeAt(i), i);
+}
+const trailingCharIndex = new Map();
+for (let i = 0; i < 64; i++) {
+    trailingCharIndex.set(constants_1.IDENTIFIER_TRAILING_DIGITS.charCodeAt(i), i);
+}
+/**
+ * Converts an identifier into the ordinal that would produce it, not accounting for reserved keywords
+ * Returns NaN if the result would exceed 31 bits
+ * @param identifier - The identifier to convert to a numeric value
+ */
+function getOrdinalFromIdentifierInternal(identifier) {
+    let ordinal = 0;
+    for (let i = identifier.length - 1; i > 0; i--) {
+        if (ordinal >= 0x2000000) {
+            return NaN;
+        }
+        ordinal <<= 6; // eslint-disable-line no-bitwise
+        ordinal += trailingCharIndex.get(identifier.charCodeAt(i)) + 1;
+    }
+    if (ordinal >= 0x2000000) {
+        return NaN;
+    }
+    ordinal *= 54;
+    ordinal += leadingCharIndex.get(identifier.charCodeAt(0));
+    return ordinal;
+}
+exports.getOrdinalFromIdentifierInternal = getOrdinalFromIdentifierInternal;
+/**
+ * getIdentifier(n) would otherwise return each of these specified ECMAScript reserved keywords, which are not legal identifiers.
+ */
+const RESERVED_ORDINALS = (() => {
+    const reserved = [];
+    for (const keyword of RESERVED_KEYWORDS) {
+        const ordinal = getOrdinalFromIdentifierInternal(keyword);
+        if (!isNaN(ordinal)) {
+            reserved.push(ordinal);
+        }
+    }
+    return reserved.sort((x, y) => x - y);
+})();
+/**
+ * Gets a base54 string suitable for use as a JavaScript identifier, omitting those that are valid ECMAScript keywords
+ *
+ * @param ordinal - The number to convert to a base54 identifier
+ *
+ * @public
+ */
+function getIdentifier(ordinal) {
+    // Need to skip over reserved keywords
+    for (let i = 0, len = RESERVED_ORDINALS.length; i < len && ordinal >= RESERVED_ORDINALS[i]; i++) {
+        ++ordinal;
+    }
+    return getIdentifierInternal(ordinal);
+}
+exports.getIdentifier = getIdentifier;
+//# sourceMappingURL=MinifiedIdentifier.js.map