diff options
Diffstat (limited to 'includes/search/node_modules/pkg/lib-es5/walker.js')
| -rw-r--r-- | includes/search/node_modules/pkg/lib-es5/walker.js | 853 |
1 files changed, 853 insertions, 0 deletions
diff --git a/includes/search/node_modules/pkg/lib-es5/walker.js b/includes/search/node_modules/pkg/lib-es5/walker.js new file mode 100644 index 0000000..abeb60c --- /dev/null +++ b/includes/search/node_modules/pkg/lib-es5/walker.js @@ -0,0 +1,853 @@ +"use strict"; +/* eslint-disable require-atomic-updates */ +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 }); +const assert_1 = __importDefault(require("assert")); +const fs_extra_1 = __importDefault(require("fs-extra")); +const is_core_module_1 = __importDefault(require("is-core-module")); +const globby_1 = __importDefault(require("globby")); +const path_1 = __importDefault(require("path")); +const chalk_1 = __importDefault(require("chalk")); +const common_1 = require("./common"); +const follow_1 = require("./follow"); +const log_1 = require("./log"); +const detector = __importStar(require("./detector")); +// Note: as a developer, you can set the PKG_STRICT_VER variable. +// this will turn on some assertion in the walker code below +// to assert that each file content/state that we appending +// to the virtual file system applies to a real file, +// not a symlink. +// By default assertion are disabled as they can have a +// performance hit. +const strictVerify = Boolean(process.env.PKG_STRICT_VER); +const win32 = process.platform === 'win32'; +function unlikelyJavascript(file) { + return ['.css', '.html', '.json', '.vue'].includes(path_1.default.extname(file)); +} +function isPublic(config) { + if (config.private) { + return false; + } + const { licenses } = config; + let { license } = config; + if (licenses) { + license = licenses; + } + if (license && !Array.isArray(license)) { + license = typeof license === 'string' ? license : license.type; + } + if (Array.isArray(license)) { + license = license.map((c) => String(c.type || c)).join(','); + } + if (!license) { + return false; + } + if (/^\(/.test(license)) { + license = license.slice(1); + } + if (/\)$/.test(license)) { + license = license.slice(0, -1); + } + license = license.toLowerCase(); + const allLicenses = Array.prototype.concat(license.split(' or '), license.split(' and '), license.split('/'), license.split(',')); + let result = false; + const foss = [ + 'isc', + 'mit', + 'apache-2.0', + 'apache 2.0', + 'public domain', + 'bsd', + 'bsd-2-clause', + 'bsd-3-clause', + 'wtfpl', + 'cc-by-3.0', + 'x11', + 'artistic-2.0', + 'gplv3', + 'mpl', + 'mplv2.0', + 'unlicense', + 'apache license 2.0', + 'zlib', + 'mpl-2.0', + 'nasa-1.3', + 'apache license, version 2.0', + 'lgpl-2.1+', + 'cc0-1.0', + ]; + for (const c of allLicenses) { + result = foss.indexOf(c) >= 0; + if (result) { + break; + } + } + return result; +} +function upon(p, base) { + if (typeof p !== 'string') { + throw (0, log_1.wasReported)('Config items must be strings. See examples'); + } + let negate = false; + if (p[0] === '!') { + p = p.slice(1); + negate = true; + } + p = path_1.default.join(base, p); + if (win32) { + p = p.replace(/\\/g, '/'); + } + if (negate) { + p = `!${p}`; + } + return p; +} +function collect(ps) { + return globby_1.default.sync(ps, { dot: true }); +} +function expandFiles(efs, base) { + if (!Array.isArray(efs)) { + efs = [efs]; + } + efs = collect(efs.map((p) => upon(p, base))); + return efs; +} +async function stepRead(record) { + if (strictVerify) { + (0, assert_1.default)(record.file === (0, common_1.toNormalizedRealPath)(record.file)); + } + let body; + try { + body = await fs_extra_1.default.readFile(record.file); + } + catch (error) { + const exception = error; + log_1.log.error(`Cannot read file, ${exception.code}`, record.file); + throw (0, log_1.wasReported)(exception.message); + } + record.body = body; +} +function stepStrip(record) { + let body = (record.body || '').toString('utf8'); + if (/^\ufeff/.test(body)) { + body = body.replace(/^\ufeff/, ''); + } + if (/^#!/.test(body)) { + body = body.replace(/^#![^\n]*\n/, '\n'); + } + record.body = body; +} +function stepDetect(record, marker, derivatives) { + let { body = '' } = record; + if (body instanceof Buffer) { + body = body.toString(); + } + try { + detector.detect(body, (node, trying) => { + const { toplevel } = marker; + let d = detector.visitorSuccessful(node); + if (d) { + if (d.mustExclude) { + return false; + } + d.mayExclude = d.mayExclude || trying; + derivatives.push(d); + return false; + } + d = detector.visitorNonLiteral(node); + if (d) { + if (typeof d === 'object' && d.mustExclude) { + return false; + } + const debug = !toplevel || d.mayExclude || trying; + const level = debug ? 'debug' : 'warn'; + log_1.log[level](`Cannot resolve '${d.alias}'`, [ + record.file, + 'Dynamic require may fail at run time, because the requested file', + 'is unknown at compilation time and not included into executable.', + "Use a string literal as an argument for 'require', or leave it", + "as is and specify the resolved file name in 'scripts' option.", + ]); + return false; + } + d = detector.visitorMalformed(node); + if (d) { + // there is no 'mustExclude' + const debug = !toplevel || trying; + const level = debug ? 'debug' : 'warn'; // there is no 'mayExclude' + log_1.log[level](`Malformed requirement for '${d.alias}'`, [record.file]); + return false; + } + d = detector.visitorUseSCWD(node); + if (d) { + // there is no 'mustExclude' + const level = 'debug'; // there is no 'mayExclude' + log_1.log[level](`Path.resolve(${d.alias}) is ambiguous`, [ + record.file, + "It resolves relatively to 'process.cwd' by default, however", + "you may want to use 'path.dirname(require.main.filename)'", + ]); + return false; + } + return true; // can i go inside? + }); + } + catch (error) { + log_1.log.error(error.message, record.file); + throw (0, log_1.wasReported)(error.message); + } +} +function findCommonJunctionPoint(file, realFile) { + // find common denominator => where the link changes + while ((0, common_1.toNormalizedRealPath)(path_1.default.dirname(file)) === path_1.default.dirname(realFile)) { + file = path_1.default.dirname(file); + realFile = path_1.default.dirname(realFile); + } + return { file, realFile }; +} +class Walker { + constructor() { + this.tasks = []; + this.records = {}; + this.dictionary = {}; + this.patches = {}; + this.params = {}; + this.symLinks = {}; + } + appendRecord({ file, store }) { + if (this.records[file]) { + return; + } + if (store === common_1.STORE_BLOB || + store === common_1.STORE_CONTENT || + store === common_1.STORE_LINKS) { + // make sure we have a real file + if (strictVerify) { + (0, assert_1.default)(file === (0, common_1.toNormalizedRealPath)(file)); + } + } + this.records[file] = { file }; + } + append(task) { + if (strictVerify) { + (0, assert_1.default)(typeof task.file === 'string'); + (0, assert_1.default)(task.file === (0, common_1.normalizePath)(task.file)); + } + this.appendRecord(task); + this.tasks.push(task); + const what = { + [common_1.STORE_BLOB]: 'Bytecode of', + [common_1.STORE_CONTENT]: 'Content of', + [common_1.STORE_LINKS]: 'Directory', + [common_1.STORE_STAT]: 'Stat info of', + }[task.store]; + if (task.reason) { + log_1.log.debug(`${what} ${task.file} is added to queue. It was required from ${task.reason}`); + } + else { + log_1.log.debug(`${what} ${task.file} is added to queue.`); + } + } + appendSymlink(file, realFile) { + const a = findCommonJunctionPoint(file, realFile); + file = a.file; + realFile = a.realFile; + if (!this.symLinks[file]) { + const dn = path_1.default.dirname(file); + this.appendFileInFolder({ + file: dn, + store: common_1.STORE_LINKS, + data: path_1.default.basename(file), + }); + log_1.log.debug(`adding symlink ${file} => ${path_1.default.relative(file, realFile)}`); + this.symLinks[file] = realFile; + this.appendStat({ + file: realFile, + store: common_1.STORE_STAT, + }); + this.appendStat({ + file: dn, + store: common_1.STORE_STAT, + }); + this.appendStat({ + file, + store: common_1.STORE_STAT, + }); + } + } + appendStat(task) { + (0, assert_1.default)(task.store === common_1.STORE_STAT); + this.append(task); + } + appendFileInFolder(task) { + if (strictVerify) { + (0, assert_1.default)(task.store === common_1.STORE_LINKS); + (0, assert_1.default)(typeof task.file === 'string'); + } + const realFile = (0, common_1.toNormalizedRealPath)(task.file); + if (realFile === task.file) { + this.append(task); + return; + } + this.append(Object.assign(Object.assign({}, task), { file: realFile })); + this.appendStat({ + file: task.file, + store: common_1.STORE_STAT, + }); + this.appendStat({ + file: path_1.default.dirname(task.file), + store: common_1.STORE_STAT, + }); + } + appendBlobOrContent(task) { + if (strictVerify) { + (0, assert_1.default)(task.file === (0, common_1.normalizePath)(task.file)); + } + (0, assert_1.default)(task.store === common_1.STORE_BLOB || task.store === common_1.STORE_CONTENT); + (0, assert_1.default)(typeof task.file === 'string'); + const realFile = (0, common_1.toNormalizedRealPath)(task.file); + if (realFile === task.file) { + this.append(task); + return; + } + this.append(Object.assign(Object.assign({}, task), { file: realFile })); + this.appendSymlink(task.file, realFile); + this.appendStat({ + file: task.file, + store: common_1.STORE_STAT, + }); + } + async appendFilesFromConfig(marker) { + const { config, configPath, base } = marker; + const pkgConfig = config === null || config === void 0 ? void 0 : config.pkg; + if (pkgConfig) { + let { scripts } = pkgConfig; + if (scripts) { + scripts = expandFiles(scripts, base); + for (const script of scripts) { + const stat = await fs_extra_1.default.stat(script); + if (stat.isFile()) { + if (!(0, common_1.isDotJS)(script) && !(0, common_1.isDotJSON)(script) && !(0, common_1.isDotNODE)(script)) { + log_1.log.warn("Non-javascript file is specified in 'scripts'.", [ + 'Pkg will probably fail to parse. Specify *.js in glob.', + script, + ]); + } + this.appendBlobOrContent({ + file: (0, common_1.normalizePath)(script), + marker, + store: common_1.STORE_BLOB, + reason: configPath, + }); + } + } + } + let { assets } = pkgConfig; + if (assets) { + assets = expandFiles(assets, base); + for (const asset of assets) { + log_1.log.debug(' Adding asset : .... ', asset); + const stat = await fs_extra_1.default.stat(asset); + if (stat.isFile()) { + this.appendBlobOrContent({ + file: (0, common_1.normalizePath)(asset), + marker, + store: common_1.STORE_CONTENT, + reason: configPath, + }); + } + } + } + } + else if (config) { + let { files } = config; + if (files) { + files = expandFiles(files, base); + for (let file of files) { + file = (0, common_1.normalizePath)(file); + const stat = await fs_extra_1.default.stat(file); + if (stat.isFile()) { + // 1) remove sources of top-level(!) package 'files' i.e. ship as BLOB + // 2) non-source (non-js) files of top-level package are shipped as CONTENT + // 3) parsing some js 'files' of non-top-level packages fails, hence all CONTENT + if (marker.toplevel) { + this.appendBlobOrContent({ + file, + marker, + store: (0, common_1.isDotJS)(file) ? common_1.STORE_BLOB : common_1.STORE_CONTENT, + reason: configPath, + }); + } + else { + this.appendBlobOrContent({ + file, + marker, + store: common_1.STORE_CONTENT, + reason: configPath, + }); + } + } + } + } + } + } + async stepActivate(marker, derivatives) { + if (!marker) { + (0, assert_1.default)(false); + } + if (marker.activated) { + return; + } + const { config, base } = marker; + if (!config) { + (0, assert_1.default)(false); + } + const { name } = config; + if (name) { + const d = this.dictionary[name]; + if (d) { + if (typeof config.dependencies === 'object' && + typeof d.dependencies === 'object') { + Object.assign(config.dependencies, d.dependencies); + delete d.dependencies; + } + Object.assign(config, d); + marker.hasDictionary = true; + } + } + const { dependencies } = config; + if (typeof dependencies === 'object') { + for (const dependency in dependencies) { + // it may be `undefined` - overridden + // in dictionary (see publicsuffixlist) + if (dependencies[dependency]) { + derivatives.push({ + alias: dependency, + aliasType: common_1.ALIAS_AS_RESOLVABLE, + fromDependencies: true, + }); + derivatives.push({ + alias: `${dependency}/package.json`, + aliasType: common_1.ALIAS_AS_RESOLVABLE, + fromDependencies: true, + }); + } + } + } + const pkgConfig = config.pkg; + if (pkgConfig) { + const { patches } = pkgConfig; + if (patches) { + for (const key in patches) { + if (patches[key]) { + const p = path_1.default.join(base, key); + this.patches[p] = patches[key]; + } + } + } + const { deployFiles } = pkgConfig; + if (deployFiles) { + marker.hasDeployFiles = true; + for (const deployFile of deployFiles) { + const type = deployFile[2] || 'file'; + log_1.log.warn(`Cannot include ${type} %1 into executable.`, [ + `The ${type} must be distributed with executable as %2.`, + `%1: ${path_1.default.relative(process.cwd(), path_1.default.join(base, deployFile[0]))}`, + `%2: path-to-executable/${deployFile[1]}`, + ]); + } + } + if (pkgConfig.log) { + pkgConfig.log(log_1.log, { packagePath: base }); + } + } + await this.appendFilesFromConfig(marker); + marker.public = isPublic(config); + if (!marker.public && marker.toplevel) { + marker.public = this.params.publicToplevel; + } + if (!marker.public && !marker.toplevel && this.params.publicPackages) { + marker.public = + this.params.publicPackages[0] === '*' || + (!!name && this.params.publicPackages.indexOf(name) !== -1); + } + marker.activated = true; + // assert no further work with config + delete marker.config; + } + hasPatch(record) { + const patch = this.patches[record.file]; + if (!patch) { + return; + } + return true; + } + stepPatch(record) { + const patch = this.patches[record.file]; + if (!patch) { + return; + } + let body = (record.body || '').toString('utf8'); + for (let i = 0; i < patch.length; i += 2) { + if (typeof patch[i] === 'object') { + if (patch[i].do === 'erase') { + body = patch[i + 1]; + } + else if (patch[i].do === 'prepend') { + body = patch[i + 1] + body; + } + else if (patch[i].do === 'append') { + body += patch[i + 1]; + } + } + else if (typeof patch[i] === 'string') { + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions + // function escapeRegExp + const esc = patch[i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); + const regexp = new RegExp(esc, 'g'); + body = body.replace(regexp, patch[i + 1]); + } + } + record.body = body; + } + async stepDerivatives_ALIAS_AS_RELATIVE(record, marker, derivative) { + const file = (0, common_1.normalizePath)(path_1.default.join(path_1.default.dirname(record.file), derivative.alias)); + let stat; + try { + stat = await fs_extra_1.default.stat(file); + } + catch (error) { + const { toplevel } = marker; + const exception = error; + const debug = !toplevel && exception.code === 'ENOENT'; + const level = debug ? 'debug' : 'warn'; + log_1.log[level](`Cannot stat, ${exception.code}`, [ + file, + `The file was required from '${record.file}'`, + ]); + } + if (stat && stat.isFile()) { + this.appendBlobOrContent({ + file, + marker, + store: common_1.STORE_CONTENT, + reason: record.file, + }); + } + } + async stepDerivatives_ALIAS_AS_RESOLVABLE(record, marker, derivative) { + var _a, _b; + const newPackages = []; + const catchReadFile = (file) => { + (0, assert_1.default)((0, common_1.isPackageJson)(file), `walker: ${file} must be package.json`); + newPackages.push({ packageJson: file }); + }; + const catchPackageFilter = (config, base) => { + const newPackage = newPackages[newPackages.length - 1]; + newPackage.marker = { config, configPath: newPackage.packageJson, base }; + }; + let newFile = ''; + let failure; + const basedir = path_1.default.dirname(record.file); + try { + newFile = await (0, follow_1.follow)(derivative.alias, { + basedir, + // default is extensions: ['.js'], but + // it is not enough because 'typos.json' + // is not taken in require('./typos') + // in 'normalize-package-data/lib/fixer.js' + extensions: ['.js', '.json', '.node'], + catchReadFile, + catchPackageFilter, + }); + } + catch (error) { + failure = error; + } + if (failure) { + const { toplevel } = marker; + const mainNotFound = newPackages.length > 0 && !((_b = (_a = newPackages[0].marker) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.main); + const debug = !toplevel || + derivative.mayExclude || + (mainNotFound && derivative.fromDependencies); + const level = debug ? 'debug' : 'warn'; + if (mainNotFound) { + const message = "Entry 'main' not found in %1"; + log_1.log[level](message, [ + `%1: ${newPackages[0].packageJson}`, + `%2: ${record.file}`, + ]); + } + else { + log_1.log[level](`${chalk_1.default.yellow(failure.message)} in ${record.file}`); + } + return; + } + let newPackageForNewRecords; + for (const newPackage of newPackages) { + let newFile2; + try { + newFile2 = await (0, follow_1.follow)(derivative.alias, { + basedir: path_1.default.dirname(record.file), + extensions: ['.js', '.json', '.node'], + ignoreFile: newPackage.packageJson, + }); + if (strictVerify) { + (0, assert_1.default)(newFile2 === (0, common_1.normalizePath)(newFile2)); + } + } + catch (_) { + // not setting is enough + } + if (newFile2 !== newFile) { + newPackageForNewRecords = newPackage; + break; + } + } + if (newPackageForNewRecords) { + if (strictVerify) { + (0, assert_1.default)(newPackageForNewRecords.packageJson === + (0, common_1.normalizePath)(newPackageForNewRecords.packageJson)); + } + this.appendBlobOrContent({ + file: newPackageForNewRecords.packageJson, + marker: newPackageForNewRecords.marker, + store: common_1.STORE_CONTENT, + reason: record.file, + }); + } + this.appendBlobOrContent({ + file: newFile, + marker: newPackageForNewRecords ? newPackageForNewRecords.marker : marker, + store: common_1.STORE_BLOB, + reason: record.file, + }); + } + async stepDerivatives(record, marker, derivatives) { + for (const derivative of derivatives) { + // TODO: actually use the target node version + if ((0, is_core_module_1.default)(derivative.alias, '99.0.0')) + continue; + switch (derivative.aliasType) { + case common_1.ALIAS_AS_RELATIVE: + await this.stepDerivatives_ALIAS_AS_RELATIVE(record, marker, derivative); + break; + case common_1.ALIAS_AS_RESOLVABLE: + await this.stepDerivatives_ALIAS_AS_RESOLVABLE(record, marker, derivative); + break; + default: + (0, assert_1.default)(false, `walker: unknown aliasType ${derivative.aliasType}`); + } + } + } + async step_STORE_ANY(record, marker, store) { + if (strictVerify) { + (0, assert_1.default)(record.file === (0, common_1.toNormalizedRealPath)(record.file)); + } + if (record[store] !== undefined) + return; + record[store] = false; // default is discard + this.appendStat({ + file: record.file, + store: common_1.STORE_STAT, + }); + const derivatives1 = []; + await this.stepActivate(marker, derivatives1); + await this.stepDerivatives(record, marker, derivatives1); + if (store === common_1.STORE_BLOB) { + if (unlikelyJavascript(record.file) || (0, common_1.isDotNODE)(record.file)) { + this.appendBlobOrContent({ + file: record.file, + marker, + store: common_1.STORE_CONTENT, + }); + return; // discard + } + if (marker.public || marker.hasDictionary) { + this.appendBlobOrContent({ + file: record.file, + marker, + store: common_1.STORE_CONTENT, + }); + } + } + if (store === common_1.STORE_BLOB || this.hasPatch(record)) { + if (!record.body) { + await stepRead(record); + this.stepPatch(record); + if (store === common_1.STORE_BLOB) { + stepStrip(record); + } + } + if (store === common_1.STORE_BLOB) { + const derivatives2 = []; + stepDetect(record, marker, derivatives2); + await this.stepDerivatives(record, marker, derivatives2); + } + } + record[store] = true; + } + step_STORE_LINKS(record, data) { + if (strictVerify) { + (0, assert_1.default)(record.file === (0, common_1.toNormalizedRealPath)(record.file), ' expecting real file !!!'); + } + if (record[common_1.STORE_LINKS]) { + record[common_1.STORE_LINKS].push(data); + return; + } + record[common_1.STORE_LINKS] = [data]; + if (record[common_1.STORE_STAT]) { + return; + } + this.appendStat({ + file: record.file, + store: common_1.STORE_STAT, + }); + } + async step_STORE_STAT(record) { + if (record[common_1.STORE_STAT]) + return; + const realPath = (0, common_1.toNormalizedRealPath)(record.file); + if (realPath !== record.file) { + this.appendStat({ + file: realPath, + store: common_1.STORE_STAT, + }); + } + try { + const valueStat = await fs_extra_1.default.stat(record.file); + const value = { + mode: valueStat.mode, + size: valueStat.isFile() ? valueStat.size : 0, + isFileValue: valueStat.isFile(), + isDirectoryValue: valueStat.isDirectory(), + isSocketValue: valueStat.isSocket(), + isSymbolicLinkValue: valueStat.isSymbolicLink(), + }; + record[common_1.STORE_STAT] = value; + } + catch (error) { + const exception = error; + log_1.log.error(`Cannot stat, ${exception.code}`, record.file); + throw (0, log_1.wasReported)(exception.message); + } + if (path_1.default.dirname(record.file) !== record.file) { + // root directory + this.appendFileInFolder({ + file: path_1.default.dirname(record.file), + store: common_1.STORE_LINKS, + data: path_1.default.basename(record.file), + }); + } + } + async step(task) { + const { file, store, data } = task; + const record = this.records[file]; + switch (store) { + case common_1.STORE_BLOB: + case common_1.STORE_CONTENT: + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + await this.step_STORE_ANY(record, task.marker, store); + break; + case common_1.STORE_LINKS: + this.step_STORE_LINKS(record, data); + break; + case common_1.STORE_STAT: + await this.step_STORE_STAT(record); + break; + default: + (0, assert_1.default)(false, `walker: unknown store ${store}`); + } + } + async readDictionary(marker) { + var _a, _b, _c; + if (((_a = this.params.noDictionary) === null || _a === void 0 ? void 0 : _a[0]) === '*') { + return; + } + const dd = path_1.default.join(__dirname, '../dictionary'); + const files = await fs_extra_1.default.readdir(dd); + for (const file of files) { + if (/\.js$/.test(file)) { + const name = file.slice(0, -3); + if ((_b = this.params.noDictionary) === null || _b === void 0 ? void 0 : _b.includes(file)) { + continue; + } + // eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires + const config = require(path_1.default.join(dd, file)); + this.dictionary[name] = config; + } + } + const pkgConfig = (_c = marker.config) === null || _c === void 0 ? void 0 : _c.pkg; + if (pkgConfig) { + const { dictionary } = pkgConfig; + if (dictionary) { + for (const name in dictionary) { + if (dictionary[name]) { + this.dictionary[name] = { pkg: dictionary[name] }; + } + } + } + } + } + async start(marker, entrypoint, addition, params) { + this.params = params; + this.symLinks = {}; + await this.readDictionary(marker); + entrypoint = (0, common_1.normalizePath)(entrypoint); + this.appendBlobOrContent({ + file: entrypoint, + marker, + store: common_1.STORE_BLOB, + }); + if (addition) { + addition = (0, common_1.normalizePath)(addition); + this.appendBlobOrContent({ + file: addition, + marker, + store: common_1.STORE_CONTENT, + }); + } + const { tasks } = this; + for (let i = 0; i < tasks.length; i += 1) { + // NO MULTIPLE WORKERS! THIS WILL LEAD TO NON-DETERMINISTIC + // ORDER. one-by-one fifo is the only way to iterate tasks + await this.step(tasks[i]); + } + return { + symLinks: this.symLinks, + records: this.records, + entrypoint: (0, common_1.normalizePath)(entrypoint), + }; + } +} +async function walker(...args) { + const w = new Walker(); + return w.start(...args); +} +exports.default = walker; +//# sourceMappingURL=walker.js.map
\ No newline at end of file |