@yao-pkg/pkg 5.9.0

package/lib-es5/detector.js

@@ -0,0 +1,420 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect = exports.parse = exports.visitorUseSCWD = exports.visitorMalformed = exports.visitorNonLiteral = exports.visitorSuccessful = void 0;
+const babelTypes = __importStar(require("@babel/types"));
+const babel = __importStar(require("@babel/parser"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const log_1 = require("./log");
+const common_1 = require("./common");
+function isLiteral(node) {
+    if (node == null) {
+        return false;
+    }
+    if (!node.type.endsWith('Literal')) {
+        return false;
+    }
+    if (node.type === 'TemplateLiteral' && node.expressions.length !== 0) {
+        return false;
+    }
+    return true;
+}
+function getLiteralValue(node) {
+    if (node.type === 'TemplateLiteral') {
+        return node.quasis[0].value.raw;
+    }
+    if (node.type === 'NullLiteral') {
+        throw new Error('Unexpected null in require expression');
+    }
+    if (node.type === 'RegExpLiteral') {
+        throw new Error('Unexpected regexp in require expression');
+    }
+    return node.value;
+}
+function reconstructSpecifiers(specs) {
+    if (!specs || !specs.length) {
+        return '';
+    }
+    const defaults = [];
+    for (const spec of specs) {
+        if (babelTypes.isImportDefaultSpecifier(spec)) {
+            defaults.push(spec.local.name);
+        }
+    }
+    const nonDefaults = [];
+    for (const spec of specs) {
+        if (babelTypes.isImportSpecifier(spec)) {
+            const importedName = babelTypes.isIdentifier(spec.imported)
+                ? spec.imported.name
+                : spec.imported.value;
+            if (spec.local.name === importedName) {
+                nonDefaults.push(spec.local.name);
+            }
+            else {
+                nonDefaults.push(`${importedName} as ${spec.local.name}`);
+            }
+        }
+    }
+    if (nonDefaults.length) {
+        defaults.push(`{ ${nonDefaults.join(', ')} }`);
+    }
+    return defaults.join(', ');
+}
+function reconstruct(node) {
+    let v = (0, generator_1.default)(node, { comments: false }).code.replace(/\n/g, '');
+    let v2;
+    while (true) {
+        v2 = v.replace(/\[ /g, '[').replace(/ \]/g, ']').replace(/ {2}/g, ' ');
+        if (v2 === v) {
+            break;
+        }
+        v = v2;
+    }
+    return v2;
+}
+function forge(pattern, was) {
+    return pattern
+        .replace('{c1}', ', ')
+        .replace('{v1}', `"${was.v1}"`)
+        .replace('{c2}', was.v2 ? ', ' : '')
+        .replace('{v2}', was.v2 ? `"${was.v2}"` : '')
+        .replace('{c3}', was.v3 ? ' from ' : '')
+        .replace('{v3}', was.v3 ? was.v3 : '');
+}
+function valid2(v2) {
+    return (v2 === undefined ||
+        v2 === null ||
+        v2 === 'must-exclude' ||
+        v2 === 'may-exclude');
+}
+function visitorRequireResolve(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'require' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    if (!n.arguments || !isLiteral(n.arguments[0])) {
+        return null;
+    }
+    return {
+        v1: getLiteralValue(n.arguments[0]),
+        v2: isLiteral(n.arguments[1]) ? getLiteralValue(n.arguments[1]) : null,
+    };
+}
+function visitorRequire(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isIdentifier(n.callee)) {
+        return null;
+    }
+    if (n.callee.name !== 'require') {
+        return null;
+    }
+    if (!n.arguments || !isLiteral(n.arguments[0])) {
+        return null;
+    }
+    return {
+        v1: getLiteralValue(n.arguments[0]),
+        v2: isLiteral(n.arguments[1]) ? getLiteralValue(n.arguments[1]) : null,
+    };
+}
+function visitorImport(n) {
+    if (!babelTypes.isImportDeclaration(n)) {
+        return null;
+    }
+    return { v1: n.source.value, v3: reconstructSpecifiers(n.specifiers) };
+}
+function visitorPathJoin(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object &&
+        n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'path' &&
+        n.callee.property &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'join';
+    if (!ci) {
+        return null;
+    }
+    const dn = n.arguments[0] &&
+        n.arguments[0].type === 'Identifier' &&
+        n.arguments[0].name === '__dirname';
+    if (!dn) {
+        return null;
+    }
+    const f = n.arguments && isLiteral(n.arguments[1]) && n.arguments.length === 2; // TODO concat them
+    if (!f) {
+        return null;
+    }
+    return { v1: getLiteralValue(n.arguments[1]) };
+}
+function visitorSuccessful(node, test = false) {
+    let was = visitorRequireResolve(node);
+    if (was) {
+        if (test) {
+            return forge('require.resolve({v1}{c2}{v2})', was);
+        }
+        if (!valid2(was.v2)) {
+            return null;
+        }
+        return {
+            alias: was.v1,
+            aliasType: common_1.ALIAS_AS_RESOLVABLE,
+            mustExclude: was.v2 === 'must-exclude',
+            mayExclude: was.v2 === 'may-exclude',
+        };
+    }
+    was = visitorRequire(node);
+    if (was) {
+        if (test) {
+            return forge('require({v1}{c2}{v2})', was);
+        }
+        if (!valid2(was.v2)) {
+            return null;
+        }
+        return {
+            alias: was.v1,
+            aliasType: common_1.ALIAS_AS_RESOLVABLE,
+            mustExclude: was.v2 === 'must-exclude',
+            mayExclude: was.v2 === 'may-exclude',
+        };
+    }
+    was = visitorImport(node);
+    if (was) {
+        if (test) {
+            return forge('import {v3}{c3}{v1}', was);
+        }
+        return { alias: was.v1, aliasType: common_1.ALIAS_AS_RESOLVABLE };
+    }
+    was = visitorPathJoin(node);
+    if (was) {
+        if (test) {
+            return forge('path.join(__dirname{c1}{v1})', was);
+        }
+        return { alias: was.v1, aliasType: common_1.ALIAS_AS_RELATIVE, mayExclude: false };
+    }
+    return null;
+}
+exports.visitorSuccessful = visitorSuccessful;
+function nonLiteralRequireResolve(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'require' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    if (isLiteral(n.arguments[0])) {
+        return null;
+    }
+    const m = n.arguments[1];
+    if (!m) {
+        return { v1: reconstruct(n.arguments[0]) };
+    }
+    if (!isLiteral(n.arguments[1])) {
+        return null;
+    }
+    return {
+        v1: reconstruct(n.arguments[0]),
+        v2: getLiteralValue(n.arguments[1]),
+    };
+}
+function nonLiteralRequire(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isIdentifier(n.callee)) {
+        return null;
+    }
+    if (n.callee.name !== 'require') {
+        return null;
+    }
+    if (isLiteral(n.arguments[0])) {
+        return null;
+    }
+    const m = n.arguments[1];
+    if (!m) {
+        return { v1: reconstruct(n.arguments[0]) };
+    }
+    if (!isLiteral(n.arguments[1])) {
+        return null;
+    }
+    return {
+        v1: reconstruct(n.arguments[0]),
+        v2: getLiteralValue(n.arguments[1]),
+    };
+}
+function visitorNonLiteral(n) {
+    const was = nonLiteralRequireResolve(n) || nonLiteralRequire(n);
+    if (was) {
+        if (!valid2(was.v2)) {
+            return null;
+        }
+        return {
+            alias: was.v1,
+            mustExclude: was.v2 === 'must-exclude',
+            mayExclude: was.v2 === 'may-exclude',
+        };
+    }
+    return null;
+}
+exports.visitorNonLiteral = visitorNonLiteral;
+function isRequire(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isIdentifier(n.callee)) {
+        return null;
+    }
+    if (n.callee.name !== 'require') {
+        return null;
+    }
+    const f = n.arguments && n.arguments[0];
+    if (!f) {
+        return null;
+    }
+    return { v1: reconstruct(n.arguments[0]) };
+}
+function isRequireResolve(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'require' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    const f = n.type === 'CallExpression' && n.arguments && n.arguments[0];
+    if (!f) {
+        return null;
+    }
+    return { v1: reconstruct(n.arguments[0]) };
+}
+function visitorMalformed(n) {
+    const was = isRequireResolve(n) || isRequire(n);
+    if (was) {
+        return { alias: was.v1 };
+    }
+    return null;
+}
+exports.visitorMalformed = visitorMalformed;
+function visitorUseSCWD(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'path' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    const was = { v1: n.arguments.map(reconstruct).join(', ') };
+    if (was) {
+        return { alias: was.v1 };
+    }
+    return null;
+}
+exports.visitorUseSCWD = visitorUseSCWD;
+function traverse(ast, visitor) {
+    // modified esprima-walk to support
+    // visitor return value and "trying" flag
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const stack = [[ast, false]];
+    for (let i = 0; i < stack.length; i += 1) {
+        const item = stack[i];
+        const [node] = item;
+        if (node) {
+            const trying = item[1] || babelTypes.isTryStatement(node);
+            if (visitor(node, trying)) {
+                for (const key in node) {
+                    if (node[key]) {
+                        const child = node[key];
+                        if (child instanceof Array) {
+                            for (let j = 0; j < child.length; j += 1) {
+                                stack.push([child[j], trying]);
+                            }
+                        }
+                        else if (child && typeof child.type === 'string') {
+                            stack.push([child, trying]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function parse(body) {
+    return babel.parse(body, {
+        allowImportExportEverywhere: true,
+        allowReturnOutsideFunction: true,
+    });
+}
+exports.parse = parse;
+function detect(body, visitor) {
+    let json;
+    try {
+        json = parse(body);
+    }
+    catch (error) {
+        log_1.log.warn(`Babel parse has failed: ${error.message}`);
+    }
+    if (!json) {
+        return;
+    }
+    traverse(json, visitor);
+}
+exports.detect = detect;
+//# sourceMappingURL=detector.js.map

package/lib-es5/fabricator.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shutdown = exports.fabricateTwice = exports.fabricate = void 0;
+const child_process_1 = require("child_process");
+const log_1 = require("./log");
+const script = `
+  var vm = require('vm');
+  var module = require('module');
+  var stdin = Buffer.alloc(0);
+  process.stdin.on('data', function (data) {
+    stdin = Buffer.concat([ stdin, data ]);
+    if (stdin.length >= 4) {
+      var sizeOfSnap = stdin.readInt32LE(0);
+      if (stdin.length >= 4 + sizeOfSnap + 4) {
+        var sizeOfBody = stdin.readInt32LE(4 + sizeOfSnap);
+        if (stdin.length >= 4 + sizeOfSnap + 4 + sizeOfBody) {
+          var snap = stdin.toString('utf8', 4, 4 + sizeOfSnap);
+          var body = Buffer.alloc(sizeOfBody);
+          var startOfBody = 4 + sizeOfSnap + 4;
+          stdin.copy(body, 0, startOfBody, startOfBody + sizeOfBody);
+          stdin = Buffer.alloc(0);
+          var code = module.wrap(body);
+          var s = new vm.Script(code, {
+            filename: snap,
+            produceCachedData: true,
+            sourceless: true
+          });
+          if (!s.cachedDataProduced) {
+            console.error('Pkg: Cached data not produced.');
+            process.exit(2);
+          }
+          var h = Buffer.alloc(4);
+          var b = s.cachedData;
+          h.writeInt32LE(b.length, 0);
+          process.stdout.write(h);
+          process.stdout.write(b);
+        }
+      }
+    }
+  });
+  process.stdin.resume();
+`;
+const children = {};
+function fabricate(bakes, fabricator, snap, body, cb) {
+    const activeBakes = bakes.filter((bake) => {
+        // list of bakes that don't influence the bytecode
+        const bake2 = bake.replace(/_/g, '-');
+        return !['--prof', '--v8-options', '--trace-opt', '--trace-deopt'].includes(bake2);
+    });
+    const cmd = fabricator.binaryPath;
+    const key = JSON.stringify([cmd, activeBakes]);
+    let child = children[key];
+    if (!child) {
+        const stderr = log_1.log.debugMode ? process.stdout : 'ignore';
+        children[key] = (0, child_process_1.spawn)(cmd, activeBakes.concat('-e', script), {
+            stdio: ['pipe', 'pipe', stderr],
+            env: { PKG_EXECPATH: 'PKG_INVOKE_NODEJS' },
+        });
+        child = children[key];
+    }
+    function kill() {
+        delete children[key];
+        child.kill();
+    }
+    let stdout = Buffer.alloc(0);
+    function onError(error) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        removeListeners();
+        kill();
+        cb(new Error(`Failed to make bytecode ${fabricator.nodeRange}-${fabricator.arch} for file ${snap} error (${error.message})`));
+    }
+    function onClose(code) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        removeListeners();
+        kill();
+        if (code !== 0) {
+            return cb(new Error(`Failed to make bytecode ${fabricator.nodeRange}-${fabricator.arch} for file ${snap}`));
+        }
+        // eslint-disable-next-line no-console
+        console.log(stdout.toString());
+        return cb(new Error(`${cmd} closed unexpectedly`));
+    }
+    function onData(data) {
+        stdout = Buffer.concat([stdout, data]);
+        if (stdout.length >= 4) {
+            const sizeOfBlob = stdout.readInt32LE(0);
+            if (stdout.length >= 4 + sizeOfBlob) {
+                const blob = Buffer.alloc(sizeOfBlob);
+                stdout.copy(blob, 0, 4, 4 + sizeOfBlob);
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                removeListeners();
+                return cb(undefined, blob);
+            }
+        }
+    }
+    function removeListeners() {
+        child.removeListener('error', onError);
+        child.removeListener('close', onClose);
+        child.stdin.removeListener('error', onError);
+        child.stdout.removeListener('error', onError);
+        child.stdout.removeListener('data', onData);
+    }
+    child.on('error', onError);
+    child.on('close', onClose);
+    child.stdin.on('error', onError);
+    child.stdout.on('error', onError);
+    child.stdout.on('data', onData);
+    const h = Buffer.alloc(4);
+    let b = Buffer.from(snap);
+    h.writeInt32LE(b.length, 0);
+    child.stdin.write(h);
+    child.stdin.write(b);
+    b = body;
+    h.writeInt32LE(b.length, 0);
+    child.stdin.write(h);
+    child.stdin.write(b);
+}
+exports.fabricate = fabricate;
+function fabricateTwice(bakes, fabricator, snap, body, cb) {
+    fabricate(bakes, fabricator, snap, body, (error, buffer) => {
+        // node0 can not produce second time, even if first time produced fine,
+        // probably because of 'filename' cache. also, there are weird cases
+        // when node4 can not compile as well, for example file 'lib/js-yaml/dumper.js'
+        // of package js-yaml@3.9.0 does not get bytecode second time on node4-win-x64
+        if (error)
+            return fabricate(bakes, fabricator, snap, body, cb);
+        cb(undefined, buffer);
+    });
+}
+exports.fabricateTwice = fabricateTwice;
+function shutdown() {
+    for (const key in children) {
+        if (children[key]) {
+            const child = children[key];
+            delete children[key];
+            child.kill();
+        }
+    }
+}
+exports.shutdown = shutdown;
+//# sourceMappingURL=fabricator.js.map

package/lib-es5/follow.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.follow = void 0;
+const resolve_1 = require("resolve");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const common_1 = require("./common");
+const PROOF = 'a-proof-that-main-is-captured.js';
+function parentDirectoriesContain(parent, directory) {
+    let currentParent = parent;
+    while (true) {
+        if (currentParent === directory) {
+            return true;
+        }
+        const newParent = path_1.default.dirname(currentParent);
+        if (newParent === currentParent) {
+            return false;
+        }
+        currentParent = newParent;
+    }
+}
+function follow(x, opts) {
+    // TODO async version
+    return new Promise((resolve) => {
+        resolve((0, resolve_1.sync)(x, {
+            basedir: opts.basedir,
+            extensions: opts.extensions,
+            isFile: (file) => {
+                if (opts.ignoreFile &&
+                    path_1.default.join(path_1.default.dirname(opts.ignoreFile), PROOF) === file) {
+                    return true;
+                }
+                let stat;
+                try {
+                    stat = fs_1.default.statSync(file);
+                }
+                catch (e) {
+                    const ex = e;
+                    if (ex && (ex.code === 'ENOENT' || ex.code === 'ENOTDIR'))
+                        return false;
+                    throw ex;
+                }
+                return stat.isFile() || stat.isFIFO();
+            },
+            isDirectory: (directory) => {
+                if (opts.ignoreFile &&
+                    parentDirectoriesContain(opts.ignoreFile, directory)) {
+                    return false;
+                }
+                let stat;
+                try {
+                    stat = fs_1.default.statSync(directory);
+                }
+                catch (e) {
+                    const ex = e;
+                    if (ex && (ex.code === 'ENOENT' || ex.code === 'ENOTDIR')) {
+                        return false;
+                    }
+                    throw ex;
+                }
+                return stat.isDirectory();
+            },
+            readFileSync: (file) => {
+                if (opts.ignoreFile && opts.ignoreFile === file) {
+                    return Buffer.from(`{"main":"${PROOF}"}`);
+                }
+                if (opts.catchReadFile) {
+                    opts.catchReadFile(file);
+                }
+                return fs_1.default.readFileSync(file);
+            },
+            packageFilter: (config, base, dir) => {
+                if (opts.catchPackageFilter) {
+                    opts.catchPackageFilter(config, base, dir);
+                }
+                return config;
+            },
+            /** function to synchronously resolve a potential symlink to its real path */
+            // realpathSync?: (file: string) => string;
+            realpathSync: (file) => {
+                const file2 = (0, common_1.toNormalizedRealPath)(file);
+                return file2;
+            },
+        }));
+    });
+}
+exports.follow = follow;
+//# sourceMappingURL=follow.js.map

package/lib-es5/help.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+function help() {
+    // eslint-disable-next-line no-console
+    console.log(`
+  ${chalk_1.default.bold('pkg')} [options] <input>
+
+  ${chalk_1.default.dim('Options:')}
+
+    -h, --help           output usage information
+    -v, --version        output pkg version
+    -t, --targets        comma-separated list of targets (see examples)
+    -c, --config         package.json or any json file with top-level config
+    --options            bake v8 options into executable to run with them on
+    -o, --output         output file name or template for several files
+    --out-path           path to save output one or more executables
+    -d, --debug          show more information during packaging process [off]
+    -b, --build          don't download prebuilt base binaries, build them
+    --public             speed up and disclose the sources of top-level project
+    --public-packages    force specified packages to be considered public
+    --no-bytecode        skip bytecode generation and include source files as plain js
+    --no-native-build    skip native addons build
+    --no-dict            comma-separated list of packages names to ignore dictionaries. Use --no-dict * to disable all dictionaries
+    -C, --compress       [default=None] compression algorithm = Brotli or GZip
+
+  ${chalk_1.default.dim('Examples:')}
+
+  ${chalk_1.default.gray('–')} Makes executables for Linux, macOS and Windows
+    ${chalk_1.default.cyan('$ pkg index.js')}
+  ${chalk_1.default.gray('–')} Takes package.json from cwd and follows 'bin' entry
+    ${chalk_1.default.cyan('$ pkg .')}
+  ${chalk_1.default.gray('–')} Makes executable for particular target machine
+    ${chalk_1.default.cyan('$ pkg -t node14-win-arm64 index.js')}
+  ${chalk_1.default.gray('–')} Makes executables for target machines of your choice
+    ${chalk_1.default.cyan('$ pkg -t node16-linux,node18-linux,node18-win index.js')}
+  ${chalk_1.default.gray('–')} Bakes '--expose-gc' and '--max-heap-size=34' into executable
+    ${chalk_1.default.cyan('$ pkg --options "expose-gc,max-heap-size=34" index.js')}
+  ${chalk_1.default.gray('–')} Consider packageA and packageB to be public
+    ${chalk_1.default.cyan('$ pkg --public-packages "packageA,packageB" index.js')}
+  ${chalk_1.default.gray('–')} Consider all packages to be public
+    ${chalk_1.default.cyan('$ pkg --public-packages "*" index.js')}
+  ${chalk_1.default.gray('–')} Bakes '--expose-gc' into executable
+    ${chalk_1.default.cyan('$ pkg --options expose-gc index.js')}
+  ${chalk_1.default.gray('–')} reduce size of the data packed inside the executable with GZip
+    ${chalk_1.default.cyan('$ pkg --compress GZip index.js')}
+`);
+}
+exports.default = help;
+//# sourceMappingURL=help.js.map