@yao-pkg/pkg 5.9.0

package/lib-es5/packer.js

@@ -0,0 +1,131 @@
+"use strict";
+/* eslint-disable complexity */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const common_1 = require("./common");
+const log_1 = require("./log");
+const { version } = JSON.parse(fs_extra_1.default.readFileSync(path_1.default.join(__dirname, '../package.json'), 'utf-8'));
+const bootstrapText = fs_extra_1.default
+    .readFileSync(require.resolve('../prelude/bootstrap.js'), 'utf8')
+    .replace('%VERSION%', version);
+const commonText = fs_extra_1.default.readFileSync(require.resolve('./common'), 'utf8');
+const diagnosticText = fs_extra_1.default.readFileSync(require.resolve('../prelude/diagnostic.js'), 'utf8');
+function itemsToText(items) {
+    const len = items.length;
+    return len.toString() + (len % 10 === 1 ? ' item' : ' items');
+}
+function hasAnyStore(record) {
+    // discarded records like native addons
+    for (const store of [common_1.STORE_BLOB, common_1.STORE_CONTENT, common_1.STORE_LINKS, common_1.STORE_STAT]) {
+        if (record[store])
+            return true;
+    }
+    return false;
+}
+function packer({ records, entrypoint, bytecode, }) {
+    const stripes = [];
+    for (const snap in records) {
+        if (records[snap]) {
+            const record = records[snap];
+            const { file } = record;
+            if (!hasAnyStore(record)) {
+                continue;
+            }
+            (0, assert_1.default)(record[common_1.STORE_STAT], 'packer: no STORE_STAT');
+            (0, assert_1.default)(record[common_1.STORE_BLOB] ||
+                record[common_1.STORE_CONTENT] ||
+                record[common_1.STORE_LINKS] ||
+                record[common_1.STORE_STAT]);
+            if (record[common_1.STORE_BLOB] && !bytecode) {
+                delete record[common_1.STORE_BLOB];
+                if (!record[common_1.STORE_CONTENT]) {
+                    // TODO make a test for it?
+                    throw (0, log_1.wasReported)('--no-bytecode and no source breaks final executable', [
+                        file,
+                        'Please run with "-d" and without "--no-bytecode" first, and make',
+                        'sure that debug log does not contain "was included as bytecode".',
+                    ]);
+                }
+            }
+            for (const store of [
+                common_1.STORE_BLOB,
+                common_1.STORE_CONTENT,
+                common_1.STORE_LINKS,
+                common_1.STORE_STAT,
+            ]) {
+                const value = record[store];
+                if (!value) {
+                    continue;
+                }
+                if (store === common_1.STORE_BLOB || store === common_1.STORE_CONTENT) {
+                    if (record.body === undefined) {
+                        stripes.push({ snap, store, file });
+                    }
+                    else if (Buffer.isBuffer(record.body)) {
+                        stripes.push({ snap, store, buffer: record.body });
+                    }
+                    else if (typeof record.body === 'string') {
+                        stripes.push({ snap, store, buffer: Buffer.from(record.body) });
+                    }
+                    else {
+                        (0, assert_1.default)(false, 'packer: bad STORE_BLOB/STORE_CONTENT');
+                    }
+                }
+                else if (store === common_1.STORE_LINKS) {
+                    if (Array.isArray(value)) {
+                        const dedupedValue = [...new Set(value)];
+                        log_1.log.debug('files & folders deduped = ', dedupedValue);
+                        const buffer = Buffer.from(JSON.stringify(dedupedValue));
+                        stripes.push({ snap, store, buffer });
+                    }
+                    else {
+                        (0, assert_1.default)(false, 'packer: bad STORE_LINKS');
+                    }
+                }
+                else if (store === common_1.STORE_STAT) {
+                    if (typeof value === 'object') {
+                        const newStat = Object.assign({}, value);
+                        const buffer = Buffer.from(JSON.stringify(newStat));
+                        stripes.push({ snap, store, buffer });
+                    }
+                    else {
+                        (0, assert_1.default)(false, 'packer: unknown store');
+                    }
+                }
+                if (record[common_1.STORE_CONTENT]) {
+                    const disclosed = (0, common_1.isDotJS)(file) || (0, common_1.isDotJSON)(file);
+                    log_1.log.debug(disclosed
+                        ? 'The file was included as DISCLOSED code (with sources)'
+                        : 'The file was included as asset content', file);
+                }
+                else if (record[common_1.STORE_BLOB]) {
+                    log_1.log.debug('The file was included as bytecode (no sources)', file);
+                }
+                else if (record[common_1.STORE_LINKS]) {
+                    const link = record[common_1.STORE_LINKS];
+                    log_1.log.debug(`The directory files list was included (${itemsToText(link)})`, file);
+                }
+            }
+        }
+    }
+    const prelude = `return (function (REQUIRE_COMMON, VIRTUAL_FILESYSTEM, DEFAULT_ENTRYPOINT, SYMLINKS, DICT, DOCOMPRESS) {
+        ${bootstrapText}${log_1.log.debugMode ? diagnosticText : ''}\n})(function (exports) {\n${commonText}\n},\n` +
+        `%VIRTUAL_FILESYSTEM%` +
+        `\n,\n` +
+        `%DEFAULT_ENTRYPOINT%` +
+        `\n,\n` +
+        `%SYMLINKS%` +
+        '\n,\n' +
+        '%DICT%' +
+        '\n,\n' +
+        '%DOCOMPRESS%' +
+        `\n);`;
+    return { prelude, entrypoint, stripes };
+}
+exports.default = packer;
+//# sourceMappingURL=packer.js.map

package/lib-es5/producer.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const multistream_1 = __importDefault(require("multistream"));
+const assert_1 = __importDefault(require("assert"));
+const child_process_1 = require("child_process");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const into_stream_1 = __importDefault(require("into-stream"));
+const path_1 = __importDefault(require("path"));
+const stream_meter_1 = __importDefault(require("stream-meter"));
+const common_1 = require("./common");
+const log_1 = require("./log");
+const fabricator_1 = require("./fabricator");
+const types_1 = require("./types");
+const compress_type_1 = require("./compress_type");
+function discoverPlaceholder(binaryBuffer, searchString, padder) {
+    const placeholder = Buffer.from(searchString);
+    const position = binaryBuffer.indexOf(placeholder);
+    if (position === -1) {
+        return { notFound: true };
+    }
+    return { position, size: placeholder.length, padder };
+}
+function injectPlaceholder(fd, placeholder, value, cb) {
+    if ('notFound' in placeholder) {
+        (0, assert_1.default)(false, 'Placeholder for not found');
+    }
+    const { position, size, padder } = placeholder;
+    let stringValue = Buffer.from('');
+    if (typeof value === 'number') {
+        stringValue = Buffer.from(value.toString());
+    }
+    else if (typeof value === 'string') {
+        stringValue = Buffer.from(value);
+    }
+    else {
+        stringValue = value;
+    }
+    const padding = Buffer.from(padder.repeat(size - stringValue.length));
+    stringValue = Buffer.concat([stringValue, padding]);
+    fs_extra_1.default.write(fd, stringValue, 0, stringValue.length, position, cb);
+}
+function discoverPlaceholders(binaryBuffer) {
+    return {
+        BAKERY: discoverPlaceholder(binaryBuffer, `\0${'// BAKERY '.repeat(20)}`, '\0'),
+        PAYLOAD_POSITION: discoverPlaceholder(binaryBuffer, '// PAYLOAD_POSITION //', ' '),
+        PAYLOAD_SIZE: discoverPlaceholder(binaryBuffer, '// PAYLOAD_SIZE //', ' '),
+        PRELUDE_POSITION: discoverPlaceholder(binaryBuffer, '// PRELUDE_POSITION //', ' '),
+        PRELUDE_SIZE: discoverPlaceholder(binaryBuffer, '// PRELUDE_SIZE //', ' '),
+    };
+}
+function injectPlaceholders(fd, placeholders, values, cb) {
+    injectPlaceholder(fd, placeholders.BAKERY, values.BAKERY, (error) => {
+        if (error) {
+            return cb(error);
+        }
+        injectPlaceholder(fd, placeholders.PAYLOAD_POSITION, values.PAYLOAD_POSITION, (error2) => {
+            if (error2) {
+                return cb(error2);
+            }
+            injectPlaceholder(fd, placeholders.PAYLOAD_SIZE, values.PAYLOAD_SIZE, (error3) => {
+                if (error3) {
+                    return cb(error3);
+                }
+                injectPlaceholder(fd, placeholders.PRELUDE_POSITION, values.PRELUDE_POSITION, (error4) => {
+                    if (error4) {
+                        return cb(error4);
+                    }
+                    injectPlaceholder(fd, placeholders.PRELUDE_SIZE, values.PRELUDE_SIZE, cb);
+                });
+            });
+        });
+    });
+}
+function makeBakeryValueFromBakes(bakes) {
+    const parts = [];
+    if (bakes.length) {
+        for (let i = 0; i < bakes.length; i += 1) {
+            parts.push(Buffer.from(bakes[i]));
+            parts.push(Buffer.alloc(1));
+        }
+        parts.push(Buffer.alloc(1));
+    }
+    return Buffer.concat(parts);
+}
+function replaceDollarWise(s, sf, st) {
+    return s.replace(sf, () => st);
+}
+function makePreludeBufferFromPrelude(prelude) {
+    return Buffer.from(`(function(process, require, console, EXECPATH_FD, PAYLOAD_POSITION, PAYLOAD_SIZE) { ${prelude}\n})`);
+}
+function findPackageJson(nodeFile) {
+    let dir = nodeFile;
+    while (dir !== '/') {
+        dir = path_1.default.dirname(dir);
+        if (fs_extra_1.default.existsSync(path_1.default.join(dir, 'package.json'))) {
+            break;
+        }
+    }
+    if (dir === '/') {
+        throw new Error(`package.json not found for "${nodeFile}"`);
+    }
+    return dir;
+}
+function nativePrebuildInstall(target, nodeFile) {
+    var _a, _b;
+    const prebuildInstall = path_1.default.join(__dirname, '../node_modules/.bin/prebuild-install');
+    const dir = findPackageJson(nodeFile);
+    // parse the target node version from the binaryPath
+    const nodeVersion = path_1.default.basename(target.binaryPath).split('-')[1];
+    if (!/^v[0-9]+\.[0-9]+\.[0-9]+$/.test(nodeVersion)) {
+        throw new Error(`Couldn't find node version, instead got: ${nodeVersion}`);
+    }
+    const nativeFile = `${nodeFile}.${target.platform}.${nodeVersion}`;
+    if (fs_extra_1.default.existsSync(nativeFile)) {
+        return nativeFile;
+    }
+    // prebuild-install will overwrite the target .node file, so take a backup
+    if (!fs_extra_1.default.existsSync(`${nodeFile}.bak`)) {
+        fs_extra_1.default.copyFileSync(nodeFile, `${nodeFile}.bak`);
+    }
+    const napiVersions = (_b = (_a = JSON.parse(fs_extra_1.default.readFileSync(path_1.default.join(dir, 'package.json'), { encoding: 'utf-8' }))) === null || _a === void 0 ? void 0 : _a.binary) === null || _b === void 0 ? void 0 : _b.napi_versions;
+    const options = [
+        '--platform',
+        types_1.platform[target.platform],
+        '--arch',
+        target.arch,
+    ];
+    if (napiVersions == null) {
+        // TODO: consider target node version and supported n-api version
+        options.push('--target', nodeVersion);
+    }
+    // run prebuild
+    (0, child_process_1.execFileSync)(prebuildInstall, options, { cwd: dir });
+    // move the prebuild to a new name with a platform/version extension
+    fs_extra_1.default.copyFileSync(nodeFile, nativeFile);
+    // put the backed up file back
+    fs_extra_1.default.moveSync(`${nodeFile}.bak`, nodeFile, { overwrite: true });
+    return nativeFile;
+}
+/**
+ * instead of creating a vfs dicionnary with actual path as key
+ * we use a compression mechanism that can reduce significantly
+ * the memory footprint of the vfs in the code.
+ *
+ * without vfs compression:
+ *
+ * vfs = {
+ *   "/folder1/folder2/file1.js": {};
+ *   "/folder1/folder2/folder3/file2.js": {};
+ *   "/folder1/folder2/folder3/file3.js": {};
+ * }
+ *
+ * with compression :
+ *
+ * fileDictionary = {
+ *    "folder1": "1",
+ *    "folder2": "2",
+ *    "file1": "3",
+ *    "folder3": "4",
+ *    "file2": "5",
+ *    "file3": "6",
+ * }
+ * vfs = {
+ *   "/1/2/3": {};
+ *   "/1/2/4/5": {};
+ *   "/1/2/4/6": {};
+ * }
+ *
+ * note: the key is computed in base36 for further compression.
+ */
+const fileDictionary = {};
+let counter = 0;
+function getOrCreateHash(fileOrFolderName) {
+    let existingKey = fileDictionary[fileOrFolderName];
+    if (!existingKey) {
+        const newkey = counter;
+        counter += 1;
+        existingKey = newkey.toString(36);
+        fileDictionary[fileOrFolderName] = existingKey;
+    }
+    return existingKey;
+}
+const separator = '/';
+function makeKey(doCompression, fullpath, slash) {
+    if (doCompression === compress_type_1.CompressType.None)
+        return fullpath;
+    return fullpath.split(slash).map(getOrCreateHash).join(separator);
+}
+function producer({ backpack, bakes, slash, target, symLinks, doCompress, nativeBuild, }) {
+    return new Promise((resolve, reject) => {
+        if (!Buffer.alloc) {
+            throw (0, log_1.wasReported)('Your node.js does not have Buffer.alloc. Please upgrade!');
+        }
+        const { prelude } = backpack;
+        let { entrypoint, stripes } = backpack;
+        entrypoint = (0, common_1.snapshotify)(entrypoint, slash);
+        stripes = stripes.slice();
+        const vfs = {};
+        for (const stripe of stripes) {
+            let { snap } = stripe;
+            snap = (0, common_1.snapshotify)(snap, slash);
+            const vfsKey = makeKey(doCompress, snap, slash);
+            if (!vfs[vfsKey])
+                vfs[vfsKey] = {};
+        }
+        const snapshotSymLinks = {};
+        for (const [key, value] of Object.entries(symLinks)) {
+            const k = (0, common_1.snapshotify)(key, slash);
+            const v = (0, common_1.snapshotify)(value, slash);
+            const vfsKey = makeKey(doCompress, k, slash);
+            snapshotSymLinks[vfsKey] = makeKey(doCompress, v, slash);
+        }
+        let meter;
+        let count = 0;
+        function pipeToNewMeter(s) {
+            meter = (0, stream_meter_1.default)();
+            return s.pipe(meter);
+        }
+        function pipeMayCompressToNewMeter(s) {
+            if (doCompress === compress_type_1.CompressType.GZip) {
+                return pipeToNewMeter(s.pipe((0, zlib_1.createGzip)()));
+            }
+            if (doCompress === compress_type_1.CompressType.Brotli) {
+                return pipeToNewMeter(s.pipe((0, zlib_1.createBrotliCompress)()));
+            }
+            return pipeToNewMeter(s);
+        }
+        function next(s) {
+            count += 1;
+            return pipeToNewMeter(s);
+        }
+        const binaryBuffer = fs_extra_1.default.readFileSync(target.binaryPath);
+        const placeholders = discoverPlaceholders(binaryBuffer);
+        let track = 0;
+        let prevStripe;
+        let payloadPosition;
+        let payloadSize;
+        let preludePosition;
+        let preludeSize;
+        new multistream_1.default((cb) => {
+            if (count === 0) {
+                return cb(null, next((0, into_stream_1.default)(binaryBuffer)));
+            }
+            if (count === 1) {
+                payloadPosition = meter.bytes;
+                return cb(null, next((0, into_stream_1.default)(Buffer.alloc(0))));
+            }
+            if (count === 2) {
+                if (prevStripe && !prevStripe.skip) {
+                    const { store } = prevStripe;
+                    let { snap } = prevStripe;
+                    snap = (0, common_1.snapshotify)(snap, slash);
+                    const vfsKey = makeKey(doCompress, snap, slash);
+                    vfs[vfsKey][store] = [track, meter.bytes];
+                    track += meter.bytes;
+                }
+                if (stripes.length) {
+                    // clone to prevent 'skip' propagate
+                    // to other targets, since same stripe
+                    // is used for several targets
+                    const stripe = Object.assign({}, stripes.shift());
+                    prevStripe = stripe;
+                    if (stripe.buffer) {
+                        if (stripe.store === common_1.STORE_BLOB) {
+                            const snap = (0, common_1.snapshotify)(stripe.snap, slash);
+                            return (0, fabricator_1.fabricateTwice)(bakes, target.fabricator, snap, stripe.buffer, (error, buffer) => {
+                                if (error) {
+                                    log_1.log.warn(error.message);
+                                    stripe.skip = true;
+                                    return cb(null, (0, into_stream_1.default)(Buffer.alloc(0)));
+                                }
+                                cb(null, pipeMayCompressToNewMeter((0, into_stream_1.default)(buffer || Buffer.from(''))));
+                            });
+                        }
+                        return cb(null, pipeMayCompressToNewMeter((0, into_stream_1.default)(stripe.buffer)));
+                    }
+                    if (stripe.file) {
+                        if (stripe.file === target.output) {
+                            return cb((0, log_1.wasReported)('Trying to take executable into executable', stripe.file), null);
+                        }
+                        assert_1.default.strictEqual(stripe.store, common_1.STORE_CONTENT); // others must be buffers from walker
+                        if ((0, common_1.isDotNODE)(stripe.file) && nativeBuild) {
+                            try {
+                                const platformFile = nativePrebuildInstall(target, stripe.file);
+                                if (fs_extra_1.default.existsSync(platformFile)) {
+                                    return cb(null, pipeMayCompressToNewMeter(fs_extra_1.default.createReadStream(platformFile)));
+                                }
+                            }
+                            catch (err) {
+                                log_1.log.debug(`prebuild-install failed[${stripe.file}]:`, err.message);
+                            }
+                        }
+                        return cb(null, pipeMayCompressToNewMeter(fs_extra_1.default.createReadStream(stripe.file)));
+                    }
+                    (0, assert_1.default)(false, 'producer: bad stripe');
+                }
+                else {
+                    payloadSize = track;
+                    preludePosition = payloadPosition + payloadSize;
+                    return cb(null, next((0, into_stream_1.default)(makePreludeBufferFromPrelude(replaceDollarWise(replaceDollarWise(replaceDollarWise(replaceDollarWise(replaceDollarWise(prelude, '%VIRTUAL_FILESYSTEM%', JSON.stringify(vfs)), '%DEFAULT_ENTRYPOINT%', JSON.stringify(entrypoint)), '%SYMLINKS%', JSON.stringify(snapshotSymLinks)), '%DICT%', JSON.stringify(fileDictionary)), '%DOCOMPRESS%', JSON.stringify(doCompress))))));
+                }
+            }
+            else {
+                return cb(null, null);
+            }
+        })
+            .on('error', (error) => {
+            reject(error);
+        })
+            .pipe(fs_extra_1.default.createWriteStream(target.output))
+            .on('error', (error) => {
+            reject(error);
+        })
+            .on('close', () => {
+            preludeSize = meter.bytes;
+            fs_extra_1.default.open(target.output, 'r+', (error, fd) => {
+                if (error)
+                    return reject(error);
+                injectPlaceholders(fd, placeholders, {
+                    BAKERY: makeBakeryValueFromBakes(bakes),
+                    PAYLOAD_POSITION: payloadPosition,
+                    PAYLOAD_SIZE: payloadSize,
+                    PRELUDE_POSITION: preludePosition,
+                    PRELUDE_SIZE: preludeSize,
+                }, (error2) => {
+                    if (error2)
+                        return reject(error2);
+                    fs_extra_1.default.close(fd, (error3) => {
+                        if (error3)
+                            return reject(error3);
+                        resolve();
+                    });
+                });
+            });
+        });
+    });
+}
+exports.default = producer;
+//# sourceMappingURL=producer.js.map

package/lib-es5/refiner.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const common_1 = require("./common");
+const log_1 = require("./log");
+const win32 = process.platform === 'win32';
+function hasParent(file, records) {
+    const dirname = path_1.default.dirname(file);
+    // root directory
+    if (dirname === file) {
+        return false;
+    }
+    return Boolean(records[dirname]);
+}
+function purgeTopDirectories(records) {
+    while (true) {
+        let found = false;
+        for (const file in records) {
+            if (records[file]) {
+                const record = records[file];
+                const links = record[common_1.STORE_LINKS];
+                if (links && links.length === 1) {
+                    if (!hasParent(file, records)) {
+                        const file2 = path_1.default.join(file, links[0]);
+                        const record2 = records[file2];
+                        const links2 = record2[common_1.STORE_LINKS];
+                        if (links2 && links2.length === 1) {
+                            const file3 = path_1.default.join(file2, links2[0]);
+                            const record3 = records[file3];
+                            const links3 = record3[common_1.STORE_LINKS];
+                            if (links3) {
+                                delete records[file];
+                                log_1.log.debug(chalk_1.default.cyan('Deleting record file :', file));
+                                found = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!found)
+            break;
+    }
+}
+function denominate(records, entrypoint, denominator, symLinks) {
+    const newRecords = {};
+    const makeSnap = (file) => {
+        let snap = (0, common_1.substituteDenominator)(file, denominator);
+        if (win32) {
+            if (snap.slice(1) === ':')
+                snap += '\\';
+        }
+        else if (snap === '') {
+            snap = '/';
+        }
+        return snap;
+    };
+    for (const file in records) {
+        if (records[file]) {
+            const snap = makeSnap(file);
+            newRecords[snap] = records[file];
+        }
+    }
+    const tmpSymLinks = symLinks;
+    symLinks = {};
+    for (const [key, value] of Object.entries(tmpSymLinks)) {
+        const key1 = makeSnap(key);
+        const value1 = makeSnap(value);
+        symLinks[key1] = value1;
+    }
+    return {
+        records: newRecords,
+        entrypoint: (0, common_1.substituteDenominator)(entrypoint, denominator),
+        symLinks,
+    };
+}
+function refiner(records, entrypoint, symLinks) {
+    purgeTopDirectories(records);
+    const denominator = (0, common_1.retrieveDenominator)(Object.keys(records));
+    return denominate(records, entrypoint, denominator, symLinks);
+}
+exports.default = refiner;
+//# sourceMappingURL=refiner.js.map

package/lib-es5/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platform = void 0;
+exports.platform = {
+    macos: 'darwin',
+    win: 'win32',
+    linux: 'linux',
+};
+//# sourceMappingURL=types.js.map