Server IP : 150.95.80.236 / Your IP : 52.15.239.254 Web Server : Apache System : Linux host-150-95-80-236 3.10.0-1160.105.1.el7.x86_64 #1 SMP Thu Dec 7 15:39:45 UTC 2023 x86_64 User : social-telecare ( 10000) PHP Version : 7.4.33 Disable Function : opcache_get_status MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/vhosts/pcu.in.th/api-uat.pcu.in.th/node_modules/@babel/core/lib/config/ |
Upload File : |
"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _async = require("../gensync-utils/async.js"); var _util = require("./util.js"); var context = require("../index.js"); var _plugin = require("./plugin.js"); var _item = require("./item.js"); var _configChain = require("./config-chain.js"); var _deepArray = require("./helpers/deep-array.js"); function _traverse() { const data = require("@babel/traverse"); _traverse = function () { return data; }; return data; } var _caching = require("./caching.js"); var _options = require("./validation/options.js"); var _plugins = require("./validation/plugins.js"); var _configApi = require("./helpers/config-api.js"); var _partial = require("./partial.js"); var _configError = require("../errors/config-error.js"); var _default = exports.default = _gensync()(function* loadFullConfig(inputOpts) { var _opts$assumptions; const result = yield* (0, _partial.default)(inputOpts); if (!result) { return null; } const { options, context, fileHandling } = result; if (fileHandling === "ignored") { return null; } const optionDefaults = {}; const { plugins, presets } = options; if (!plugins || !presets) { throw new Error("Assertion failure - plugins and presets exist"); } const presetContext = Object.assign({}, context, { targets: options.targets }); const toDescriptor = item => { const desc = (0, _item.getItemDescriptor)(item); if (!desc) { throw new Error("Assertion failure - must be config item"); } return desc; }; const presetsDescriptors = presets.map(toDescriptor); const initialPluginsDescriptors = plugins.map(toDescriptor); const pluginDescriptorsByPass = [[]]; const passes = []; const externalDependencies = []; const ignored = yield* enhanceError(context, function* recursePresetDescriptors(rawPresets, pluginDescriptorsPass) { const presets = []; for (let i = 0; i < rawPresets.length; i++) { const descriptor = rawPresets[i]; if (descriptor.options !== false) { try { var preset = yield* loadPresetDescriptor(descriptor, presetContext); } catch (e) { if (e.code === "BABEL_UNKNOWN_OPTION") { (0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e); } throw e; } externalDependencies.push(preset.externalDependencies); if (descriptor.ownPass) { presets.push({ preset: preset.chain, pass: [] }); } else { presets.unshift({ preset: preset.chain, pass: pluginDescriptorsPass }); } } } if (presets.length > 0) { pluginDescriptorsByPass.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pluginDescriptorsPass)); for (const { preset, pass } of presets) { if (!preset) return true; pass.push(...preset.plugins); const ignored = yield* recursePresetDescriptors(preset.presets, pass); if (ignored) return true; preset.options.forEach(opts => { (0, _util.mergeOptions)(optionDefaults, opts); }); } } })(presetsDescriptors, pluginDescriptorsByPass[0]); if (ignored) return null; const opts = optionDefaults; (0, _util.mergeOptions)(opts, options); const pluginContext = Object.assign({}, presetContext, { assumptions: (_opts$assumptions = opts.assumptions) != null ? _opts$assumptions : {} }); yield* enhanceError(context, function* loadPluginDescriptors() { pluginDescriptorsByPass[0].unshift(...initialPluginsDescriptors); for (const descs of pluginDescriptorsByPass) { const pass = []; passes.push(pass); for (let i = 0; i < descs.length; i++) { const descriptor = descs[i]; if (descriptor.options !== false) { try { var plugin = yield* loadPluginDescriptor(descriptor, pluginContext); } catch (e) { if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") { (0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e); } throw e; } pass.push(plugin); externalDependencies.push(plugin.externalDependencies); } } } })(); opts.plugins = passes[0]; opts.presets = passes.slice(1).filter(plugins => plugins.length > 0).map(plugins => ({ plugins })); opts.passPerPreset = opts.presets.length > 0; return { options: opts, passes: passes, externalDependencies: (0, _deepArray.finalize)(externalDependencies) }; }); function enhanceError(context, fn) { return function* (arg1, arg2) { try { return yield* fn(arg1, arg2); } catch (e) { if (!/^\[BABEL\]/.test(e.message)) { var _context$filename; e.message = `[BABEL] ${(_context$filename = context.filename) != null ? _context$filename : "unknown file"}: ${e.message}`; } throw e; } }; } const makeDescriptorLoader = apiFactory => (0, _caching.makeWeakCache)(function* ({ value, options, dirname, alias }, cache) { if (options === false) throw new Error("Assertion failure"); options = options || {}; const externalDependencies = []; let item = value; if (typeof value === "function") { const factory = (0, _async.maybeAsync)(value, `You appear to be using an async plugin/preset, but Babel has been called synchronously`); const api = Object.assign({}, context, apiFactory(cache, externalDependencies)); try { item = yield* factory(api, options, dirname); } catch (e) { if (alias) { e.message += ` (While processing: ${JSON.stringify(alias)})`; } throw e; } } if (!item || typeof item !== "object") { throw new Error("Plugin/Preset did not return an object."); } if ((0, _async.isThenable)(item)) { yield* []; throw new Error(`You appear to be using a promise as a plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version. ` + `As an alternative, you can prefix the promise with "await". ` + `(While processing: ${JSON.stringify(alias)})`); } if (externalDependencies.length > 0 && (!cache.configured() || cache.mode() === "forever")) { let error = `A plugin/preset has external untracked dependencies ` + `(${externalDependencies[0]}), but the cache `; if (!cache.configured()) { error += `has not been configured to be invalidated when the external dependencies change. `; } else { error += ` has been configured to never be invalidated. `; } error += `Plugins/presets should configure their cache to be invalidated when the external ` + `dependencies change, for example using \`api.cache.invalidate(() => ` + `statSync(filepath).mtimeMs)\` or \`api.cache.never()\`\n` + `(While processing: ${JSON.stringify(alias)})`; throw new Error(error); } return { value: item, options, dirname, alias, externalDependencies: (0, _deepArray.finalize)(externalDependencies) }; }); const pluginDescriptorLoader = makeDescriptorLoader(_configApi.makePluginAPI); const presetDescriptorLoader = makeDescriptorLoader(_configApi.makePresetAPI); const instantiatePlugin = (0, _caching.makeWeakCache)(function* ({ value, options, dirname, alias, externalDependencies }, cache) { const pluginObj = (0, _plugins.validatePluginObject)(value); const plugin = Object.assign({}, pluginObj); if (plugin.visitor) { plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor)); } if (plugin.inherits) { const inheritsDescriptor = { name: undefined, alias: `${alias}$inherits`, value: plugin.inherits, options, dirname }; const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, run => { return cache.invalidate(data => run(inheritsDescriptor, data)); }); plugin.pre = chain(inherits.pre, plugin.pre); plugin.post = chain(inherits.post, plugin.post); plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions); plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]); if (inherits.externalDependencies.length > 0) { if (externalDependencies.length === 0) { externalDependencies = inherits.externalDependencies; } else { externalDependencies = (0, _deepArray.finalize)([externalDependencies, inherits.externalDependencies]); } } } return new _plugin.default(plugin, options, alias, externalDependencies); }); function* loadPluginDescriptor(descriptor, context) { if (descriptor.value instanceof _plugin.default) { if (descriptor.options) { throw new Error("Passed options to an existing Plugin instance will not work."); } return descriptor.value; } return yield* instantiatePlugin(yield* pluginDescriptorLoader(descriptor, context), context); } const needsFilename = val => val && typeof val !== "function"; const validateIfOptionNeedsFilename = (options, descriptor) => { if (needsFilename(options.test) || needsFilename(options.include) || needsFilename(options.exclude)) { const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */"; throw new _configError.default([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transformSync(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n")); } }; const validatePreset = (preset, context, descriptor) => { if (!context.filename) { var _options$overrides; const { options } = preset; validateIfOptionNeedsFilename(options, descriptor); (_options$overrides = options.overrides) == null || _options$overrides.forEach(overrideOptions => validateIfOptionNeedsFilename(overrideOptions, descriptor)); } }; const instantiatePreset = (0, _caching.makeWeakCacheSync)(({ value, dirname, alias, externalDependencies }) => { return { options: (0, _options.validate)("preset", value), alias, dirname, externalDependencies }; }); function* loadPresetDescriptor(descriptor, context) { const preset = instantiatePreset(yield* presetDescriptorLoader(descriptor, context)); validatePreset(preset, context, descriptor); return { chain: yield* (0, _configChain.buildPresetChain)(preset, context), externalDependencies: preset.externalDependencies }; } function chain(a, b) { const fns = [a, b].filter(Boolean); if (fns.length <= 1) return fns[0]; return function (...args) { for (const fn of fns) { fn.apply(this, args); } }; } 0 && 0; //# sourceMappingURL=full.js.map