diff --git a/.circleci/config.yml b/.circleci/config.yml index bfe138f473c5..89e885ee35c2 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -202,9 +202,9 @@ workflows: - e2e-babel: requires: - publish-verdaccio - - e2e-babel-old-version: - requires: - - publish-verdaccio + # - e2e-babel-old-version: + # requires: + # - publish-verdaccio - e2e-create-react-app: requires: - publish-verdaccio diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 89f97ca93d85..d80681d2c585 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - node-version: [14, 13, 12, 10, 8, 6] + node-version: [14, 13, 12, 10] steps: - name: Checkout code uses: actions/checkout@v2 diff --git a/.gitignore b/.gitignore index 6282dfa36ce0..207124a5039b 100644 --- a/.gitignore +++ b/.gitignore @@ -69,4 +69,5 @@ packages/babel-standalone/babel.min.js /eslint/*/lib /eslint/*/LICENSE !/packages/babel-eslint-plugin/LICENSE +.watchmanconfig /.vscode diff --git a/.travis.yml b/.travis.yml index d1e22c9546fa..ae0d5372bfdb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,11 @@ language: node_js cache: npm: false directories: +<<<<<<< HEAD + - .yarn/cache +======= - ~/.yarn/berry/cache +>>>>>>> main os: linux diff --git a/.yarn/plugins/@yarnpkg/plugin-constraints.js b/.yarn/plugins/@yarnpkg/plugin-constraints.js new file mode 100644 index 000000000000..b766c582b9ab --- /dev/null +++ b/.yarn/plugins/@yarnpkg/plugin-constraints.js @@ -0,0 +1,10749 @@ +/* eslint-disable*/ +module.exports = { + name: "@yarnpkg/plugin-constraints", + factory: function (require) { + var plugin = + /******/ (function(modules) { // webpackBootstrap + /******/ // The module cache + /******/ var installedModules = {}; + /******/ + /******/ // The require function + /******/ function __webpack_require__(moduleId) { + /******/ + /******/ // Check if module is in cache + /******/ if(installedModules[moduleId]) { + /******/ return installedModules[moduleId].exports; + /******/ } + /******/ // Create a new module (and put it into the cache) + /******/ var module = installedModules[moduleId] = { + /******/ i: moduleId, + /******/ l: false, + /******/ exports: {} + /******/ }; + /******/ + /******/ // Execute the module function + /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + /******/ + /******/ // Flag the module as loaded + /******/ module.l = true; + /******/ + /******/ // Return the exports of the module + /******/ return module.exports; + /******/ } + /******/ + /******/ + /******/ // expose the modules object (__webpack_modules__) + /******/ __webpack_require__.m = modules; + /******/ + /******/ // expose the module cache + /******/ __webpack_require__.c = installedModules; + /******/ + /******/ // define getter function for harmony exports + /******/ __webpack_require__.d = function(exports, name, getter) { + /******/ if(!__webpack_require__.o(exports, name)) { + /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); + /******/ } + /******/ }; + /******/ + /******/ // define __esModule on exports + /******/ __webpack_require__.r = function(exports) { + /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { + /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + /******/ } + /******/ Object.defineProperty(exports, '__esModule', { value: true }); + /******/ }; + /******/ + /******/ // create a fake namespace object + /******/ // mode & 1: value is a module id, require it + /******/ // mode & 2: merge all properties of value into the ns + /******/ // mode & 4: return value when already ns object + /******/ // mode & 8|1: behave like require + /******/ __webpack_require__.t = function(value, mode) { + /******/ if(mode & 1) value = __webpack_require__(value); + /******/ if(mode & 8) return value; + /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; + /******/ var ns = Object.create(null); + /******/ __webpack_require__.r(ns); + /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); + /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); + /******/ return ns; + /******/ }; + /******/ + /******/ // getDefaultExport function for compatibility with non-harmony modules + /******/ __webpack_require__.n = function(module) { + /******/ var getter = module && module.__esModule ? + /******/ function getDefault() { return module['default']; } : + /******/ function getModuleExports() { return module; }; + /******/ __webpack_require__.d(getter, 'a', getter); + /******/ return getter; + /******/ }; + /******/ + /******/ // Object.prototype.hasOwnProperty.call + /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; + /******/ + /******/ // __webpack_public_path__ + /******/ __webpack_require__.p = ""; + /******/ + /******/ + /******/ // Load entry module and return exports + /******/ return __webpack_require__(__webpack_require__.s = 0); + /******/ }) + /************************************************************************/ + /******/ ([ + /* 0 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + + + var __importDefault = this && this.__importDefault || function (mod) { + return mod && mod.__esModule ? mod : { + "default": mod + }; + }; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + const core_1 = __webpack_require__(1); + + const query_1 = __importDefault(__webpack_require__(2)); + + const source_1 = __importDefault(__webpack_require__(68)); + + const constraints_1 = __importDefault(__webpack_require__(69)); + + const plugin = { + configuration: { + constraintsPath: { + description: `The path of the constraints file.`, + type: core_1.SettingsType.ABSOLUTE_PATH, + default: `./constraints.pro` + } + }, + commands: [query_1.default, source_1.default, constraints_1.default] + }; // eslint-disable-next-line arca/no-default-export + + exports.default = plugin; + + /***/ }), + /* 1 */ + /***/ (function(module, exports) { + + module.exports = require("@yarnpkg/core"); + + /***/ }), + /* 2 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + + + var __decorate = this && this.__decorate || function (decorators, target, key, desc) { + var c = arguments.length, + r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, + d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + }; + + var __asyncValues = this && this.__asyncValues || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], + i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { + return this; + }, i); + + function verb(n) { + i[n] = o[n] && function (v) { + return new Promise(function (resolve, reject) { + v = o[n](v), settle(resolve, reject, v.done, v.value); + }); + }; + } + + function settle(resolve, reject, d, v) { + Promise.resolve(v).then(function (v) { + resolve({ + value: v, + done: d + }); + }, reject); + } + }; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + const cli_1 = __webpack_require__(3); + + const core_1 = __webpack_require__(1); + + const core_2 = __webpack_require__(1); + + const clipanion_1 = __webpack_require__(4); + + const Constraints_1 = __webpack_require__(5); // eslint-disable-next-line arca/no-default-export + + + class ConstraintsQueryCommand extends cli_1.BaseCommand { + constructor() { + super(...arguments); + this.json = false; + } + + async execute() { + const configuration = await core_1.Configuration.find(this.context.cwd, this.context.plugins); + const { + project + } = await core_1.Project.find(configuration, this.context.cwd); + const constraints = await Constraints_1.Constraints.find(project); + let query = this.query; + if (!query.endsWith(`.`)) query = `${query}.`; + const report = await core_2.StreamReport.start({ + configuration, + json: this.json, + stdout: this.context.stdout + }, async report => { + var e_1, _a; + + try { + for (var _b = __asyncValues(constraints.query(query)), _c; _c = await _b.next(), !_c.done;) { + const result = _c.value; + const lines = Array.from(Object.entries(result)); + const lineCount = lines.length; + const maxVariableNameLength = lines.reduce((max, [variableName]) => Math.max(max, variableName.length), 0); + + for (let i = 0; i < lineCount; i++) { + const [variableName, value] = lines[i]; + report.reportInfo(null, `${getLinePrefix(i, lineCount)}${variableName.padEnd(maxVariableNameLength, ` `)} = ${valueToString(value)}`); + } + + report.reportJson(result); + } + } catch (e_1_1) { + e_1 = { + error: e_1_1 + }; + } finally { + try { + if (_c && !_c.done && (_a = _b.return)) await _a.call(_b); + } finally { + if (e_1) throw e_1.error; + } + } + }); + return report.exitCode(); + } + + } + + ConstraintsQueryCommand.usage = clipanion_1.Command.Usage({ + category: `Constraints-related commands`, + description: `query the constraints fact database`, + details: ` + This command will output all matches to the given prolog query. + + If the \`--json\` flag is set the output will follow a JSON-stream output also known as NDJSON (https://github.com/ndjson/ndjson-spec). + `, + examples: [[`List all dependencies throughout the workspace`, `yarn constraints query 'workspace_has_dependency(_, DependencyName, _, _).'`]] + }); + + __decorate([clipanion_1.Command.Boolean(`--json`)], ConstraintsQueryCommand.prototype, "json", void 0); + + __decorate([clipanion_1.Command.String()], ConstraintsQueryCommand.prototype, "query", void 0); + + __decorate([clipanion_1.Command.Path(`constraints`, `query`)], ConstraintsQueryCommand.prototype, "execute", null); + + exports.default = ConstraintsQueryCommand; + + function valueToString(value) { + if (typeof value !== `string`) return `${value}`; + if (value.match(/^[a-zA-Z][a-zA-Z0-9_]+$/)) return value; + return `'${value}'`; + } + + function getLinePrefix(index, count) { + const isFirst = index === 0; + const isLast = index === count - 1; + if (isFirst && isLast) return ``; + if (isFirst) return `┌ `; + if (isLast) return `└ `; + return `│ `; + } + + /***/ }), + /* 3 */ + /***/ (function(module, exports) { + + module.exports = require("@yarnpkg/cli"); + + /***/ }), + /* 4 */ + /***/ (function(module, exports) { + + module.exports = require("clipanion"); + + /***/ }), + /* 5 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + /// + + var __await = this && this.__await || function (v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); + }; + + var __asyncGenerator = this && this.__asyncGenerator || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), + i, + q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { + return this; + }, i; + + function verb(n) { + if (g[n]) i[n] = function (v) { + return new Promise(function (a, b) { + q.push([n, v, a, b]) > 1 || resume(n, v); + }); + }; + } + + function resume(n, v) { + try { + step(g[n](v)); + } catch (e) { + settle(q[0][3], e); + } + } + + function step(r) { + r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); + } + + function fulfill(value) { + resume("next", value); + } + + function reject(value) { + resume("throw", value); + } + + function settle(f, v) { + if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); + } + }; + + var __asyncValues = this && this.__asyncValues || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], + i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { + return this; + }, i); + + function verb(n) { + i[n] = o[n] && function (v) { + return new Promise(function (resolve, reject) { + v = o[n](v), settle(resolve, reject, v.done, v.value); + }); + }; + } + + function settle(resolve, reject, d, v) { + Promise.resolve(v).then(function (v) { + resolve({ + value: v, + done: d + }); + }, reject); + } + }; + + var __importDefault = this && this.__importDefault || function (mod) { + return mod && mod.__esModule ? mod : { + "default": mod + }; + }; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + const core_1 = __webpack_require__(1); + + const core_2 = __webpack_require__(1); + + const fslib_1 = __webpack_require__(6); + + const tau_prolog_1 = __importDefault(__webpack_require__(7)); + + const tauModule_1 = __webpack_require__(14); + + var DependencyType; + + (function (DependencyType) { + DependencyType["Dependencies"] = "dependencies"; + DependencyType["DevDependencies"] = "devDependencies"; + DependencyType["PeerDependencies"] = "peerDependencies"; + })(DependencyType = exports.DependencyType || (exports.DependencyType = {})); + + const DEPENDENCY_TYPES = [DependencyType.Dependencies, DependencyType.DevDependencies, DependencyType.PeerDependencies]; + + function extractErrorImpl(value) { + if (value instanceof tau_prolog_1.default.type.Num) return value.value; + + if (value instanceof tau_prolog_1.default.type.Term) { + if (value.args.length === 0) return value.id; + + switch (value.indicator) { + case `throw/1`: + return extractErrorImpl(value.args[0]); + + case `error/1`: + return extractErrorImpl(value.args[0]); + + case `error/2`: + return Object.assign(extractErrorImpl(value.args[0]), ...extractErrorImpl(value.args[1])); + + case `syntax_error/1`: + return new core_1.ReportError(core_1.MessageName.PROLOG_SYNTAX_ERROR, `Syntax error: ${extractErrorImpl(value.args[0])}`); + + case `existence_error/2`: + return new core_1.ReportError(core_1.MessageName.PROLOG_EXISTENCE_ERROR, `Existence error: ${extractErrorImpl(value.args[0])} ${extractErrorImpl(value.args[1])} not found`); + + case `line/1`: + return { + line: extractErrorImpl(value.args[0]) + }; + + case `column/1`: + return { + column: extractErrorImpl(value.args[0]) + }; + + case `found/1`: + return { + found: extractErrorImpl(value.args[0]) + }; + + case `./2`: + return [extractErrorImpl(value.args[0])].concat(extractErrorImpl(value.args[1])); + + case `//2`: + return `${extractErrorImpl(value.args[0])}/${extractErrorImpl(value.args[1])}`; + } + } + + throw `couldn't pretty print because of unsupported node ${value}`; + } + + function extractError(val) { + let err; + + try { + err = extractErrorImpl(val); + } catch (caught) { + if (typeof caught === `string`) { + throw new core_1.ReportError(core_1.MessageName.PROLOG_UNKNOWN_ERROR, `Unknown error: ${val} (note: ${caught})`); + } else { + throw caught; + } + } + + if (typeof err.line !== `undefined` && typeof err.column !== `undefined`) err.message += ` at line ${err.line}, column ${err.column}`; + return err; + } // Node 8 doesn't have Symbol.asyncIterator + // https://github.com/Microsoft/TypeScript/issues/14151#issuecomment-280812617 + + + if (Symbol.asyncIterator == null) Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator'); + + class Session { + constructor(project, source) { + this.session = tau_prolog_1.default.create(); + tauModule_1.linkProjectToSession(this.session, project); + this.session.consult(source); + } + + fetchNextAnswer() { + return new Promise(resolve => { + this.session.answer(result => { + resolve(result); + }); + }); + } + + makeQuery(query) { + return __asyncGenerator(this, arguments, function* makeQuery_1() { + const parsed = this.session.query(query); + if (parsed !== true) throw extractError(parsed); + + while (true) { + const answer = yield __await(this.fetchNextAnswer()); + if (!answer) break; + if (answer.id === `throw`) throw extractError(answer); + yield yield __await(answer); + } + }); + } + + } + + function parseLink(link) { + if (link.id === `null`) { + return null; + } else { + return `${link.toJavaScript()}`; + } + } + + function parseLinkToJson(link) { + if (link.id === `null`) { + return null; + } else { + const val = link.toJavaScript(); + if (typeof val !== `string`) return JSON.stringify(val); + + try { + return JSON.stringify(JSON.parse(val)); + } catch (_a) { + return JSON.stringify(val); + } + } + } + + class Constraints { + constructor(project) { + this.source = ``; + this.project = project; + const constraintsPath = project.configuration.get(`constraintsPath`); + + if (fslib_1.xfs.existsSync(constraintsPath)) { + this.source = fslib_1.xfs.readFileSync(constraintsPath, `utf8`); + } + } + + static async find(project) { + return new Constraints(project); + } + + getProjectDatabase() { + let database = ``; + + for (const dependencyType of DEPENDENCY_TYPES) database += `dependency_type(${dependencyType}).\n`; + + for (const workspace of this.project.workspacesByCwd.values()) { + const relativeCwd = workspace.relativeCwd; + database += `workspace(${escape(relativeCwd)}).\n`; + database += `workspace_ident(${escape(relativeCwd)}, ${escape(core_2.structUtils.stringifyIdent(workspace.locator))}).\n`; + database += `workspace_version(${escape(relativeCwd)}, ${escape(workspace.manifest.version)}).\n`; + + for (const dependencyType of DEPENDENCY_TYPES) { + for (const dependency of workspace.manifest[dependencyType].values()) { + database += `workspace_has_dependency(${escape(relativeCwd)}, ${escape(core_2.structUtils.stringifyIdent(dependency))}, ${escape(dependency.range)}, ${dependencyType}).\n`; + } + } + } // Add default never matching predicates to prevent prolog instantiation errors + // when constraints run in an empty workspace + + + database += `workspace(_) :- false.\n`; + database += `workspace_ident(_, _) :- false.\n`; + database += `workspace_version(_, _) :- false.\n`; // Add a default never matching predicate to prevent prolog instantiation errors + // when constraints run in a workspace without dependencies + + database += `workspace_has_dependency(_, _, _, _) :- false.\n`; + return database; + } + + getDeclarations() { + let declarations = ``; // (Cwd, DependencyIdent, DependencyRange, DependencyType) + + declarations += `gen_enforced_dependency(_, _, _, _) :- false.\n`; // (Cwd, Path, Value) + + declarations += `gen_enforced_field(_, _, _) :- false.\n`; + return declarations; + } + + get fullSource() { + return `${this.getProjectDatabase()}\n${this.source}\n${this.getDeclarations()}`; + } + + createSession() { + return new Session(this.project, this.fullSource); + } + + async process() { + const session = this.createSession(); + return { + enforcedDependencies: await this.genEnforcedDependencies(session), + enforcedFields: await this.genEnforcedFields(session) + }; + } + + async genEnforcedDependencies(session) { + var e_1, _a; + + let enforcedDependencies = []; + + try { + for (var _b = __asyncValues(session.makeQuery(`workspace(WorkspaceCwd), dependency_type(DependencyType), gen_enforced_dependency(WorkspaceCwd, DependencyIdent, DependencyRange, DependencyType).`)), _c; _c = await _b.next(), !_c.done;) { + const answer = _c.value; + const workspaceCwd = fslib_1.ppath.resolve(this.project.cwd, parseLink(answer.links.WorkspaceCwd)); + const dependencyRawIdent = parseLink(answer.links.DependencyIdent); + const dependencyRange = parseLink(answer.links.DependencyRange); + const dependencyType = parseLink(answer.links.DependencyType); + if (workspaceCwd === null || dependencyRawIdent === null) throw new Error(`Invalid rule`); + const workspace = this.project.getWorkspaceByCwd(workspaceCwd); + const dependencyIdent = core_2.structUtils.parseIdent(dependencyRawIdent); + enforcedDependencies.push({ + workspace, + dependencyIdent, + dependencyRange, + dependencyType + }); + } + } catch (e_1_1) { + e_1 = { + error: e_1_1 + }; + } finally { + try { + if (_c && !_c.done && (_a = _b.return)) await _a.call(_b); + } finally { + if (e_1) throw e_1.error; + } + } + + return core_2.miscUtils.sortMap(enforcedDependencies, [({ + dependencyRange + }) => dependencyRange !== null ? `0` : `1`, ({ + workspace + }) => core_2.structUtils.stringifyIdent(workspace.locator), ({ + dependencyIdent + }) => core_2.structUtils.stringifyIdent(dependencyIdent)]); + } + + async genEnforcedFields(session) { + var e_2, _a; + + let enforcedFields = []; + + try { + for (var _b = __asyncValues(session.makeQuery(`workspace(WorkspaceCwd), gen_enforced_field(WorkspaceCwd, FieldPath, FieldValue).`)), _c; _c = await _b.next(), !_c.done;) { + const answer = _c.value; + const workspaceCwd = fslib_1.ppath.resolve(this.project.cwd, parseLink(answer.links.WorkspaceCwd)); + const fieldPath = parseLink(answer.links.FieldPath); + let fieldValue = parseLinkToJson(answer.links.FieldValue); + if (workspaceCwd === null || fieldPath === null) throw new Error(`Invalid rule`); + const workspace = this.project.getWorkspaceByCwd(workspaceCwd); + enforcedFields.push({ + workspace, + fieldPath, + fieldValue + }); + } + } catch (e_2_1) { + e_2 = { + error: e_2_1 + }; + } finally { + try { + if (_c && !_c.done && (_a = _b.return)) await _a.call(_b); + } finally { + if (e_2) throw e_2.error; + } + } + + return core_2.miscUtils.sortMap(enforcedFields, [({ + workspace + }) => core_2.structUtils.stringifyIdent(workspace.locator), ({ + fieldPath + }) => fieldPath]); + } + + query(query) { + return __asyncGenerator(this, arguments, function* query_1() { + var e_3, _a; + + const session = this.createSession(); + + try { + for (var _b = __asyncValues(session.makeQuery(query)), _c; _c = yield __await(_b.next()), !_c.done;) { + const answer = _c.value; + const parsedLinks = {}; + + for (const [variable, value] of Object.entries(answer.links)) { + if (variable !== `_`) { + parsedLinks[variable] = parseLink(value); + } + } + + yield yield __await(parsedLinks); + } + } catch (e_3_1) { + e_3 = { + error: e_3_1 + }; + } finally { + try { + if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b)); + } finally { + if (e_3) throw e_3.error; + } + } + }); + } + + } + + exports.Constraints = Constraints; + + function escape(what) { + if (typeof what === `string`) { + return `'${what}'`; + } else { + return `[]`; + } + } + + /***/ }), + /* 6 */ + /***/ (function(module, exports) { + + module.exports = require("@yarnpkg/fslib"); + + /***/ }), + /* 7 */ + /***/ (function(module, exports, __webpack_require__) { + + (function() { + + // VERSION + var version = { major: 0, minor: 2, patch: 66, status: "beta" }; + + + + // IO FILE SYSTEM + + // Virtual file system for browser + tau_file_system = { + // Current files + files: {}, + // Open file + open: function( path, type, mode ) { + var file = tau_file_system.files[path]; + if( !file ) { + if( mode === "read" ) + return null; + file = { + path: path, + text: "", + type: type, + get: function( length, position ) { + if( position === this.text.length ) { + return "end_of_file"; + } else if( position > this.text.length ) { + return "end_of_file"; + } else { + return this.text.substring( position, position+length ); + } + }, + put: function( text, position ) { + if( position === "end_of_file" ) { + this.text += text; + return true; + } else if( position === "past_end_of_file" ) { + return null; + } else { + this.text = this.text.substring(0, position) + text + this.text.substring(position+text.length); + return true; + } + }, + get_byte: function( position ) { + if( position === "end_of_stream" ) + return -1; + var index = Math.floor(position/2); + if( this.text.length <= index ) + return -1; + var code = codePointAt( this.text[Math.floor(position/2)], 0 ); + if( position % 2 === 0 ) + return code & 0xff; + else + return code / 256 >>> 0; + }, + put_byte: function( byte, position ) { + var index = position === "end_of_stream" ? this.text.length : Math.floor(position/2); + if( this.text.length < index ) + return null; + var code = this.text.length === index ? -1 : codePointAt( this.text[Math.floor(position/2)], 0 ); + if( position % 2 === 0 ) { + code = code / 256 >>> 0; + code = ((code & 0xff) << 8) | (byte & 0xff); + } else { + code = code & 0xff; + code = ((byte & 0xff) << 8) | (code & 0xff); + } + if( this.text.length === index ) + this.text += fromCodePoint( code ); + else + this.text = this.text.substring( 0, index ) + fromCodePoint( code ) + this.text.substring( index+1 ); + return true; + }, + flush: function() { + return true; + }, + close: function() { + var file = tau_file_system.files[this.path]; + if( !file ) { + return null; + } else { + return true; + } + } + }; + tau_file_system.files[path] = file; + } + if( mode === "write" ) + file.text = ""; + return file; + }, + }; + + // User input for browser + tau_user_input = { + buffer: "", + get: function( length, _ ) { + var text; + while( tau_user_input.buffer.length < length ) { + text = window.prompt(); + if( text ) { + tau_user_input.buffer += text; + } + } + text = tau_user_input.buffer.substr( 0, length ); + tau_user_input.buffer = tau_user_input.buffer.substr( length ); + return text; + } + }; + + // User output for browser + tau_user_output = { + put: function( text, _ ) { + console.log( text ); + return true; + }, + flush: function() { + return true; + } + }; + + // Virtual file system for Node.js + nodejs_file_system = { + // Open file + open: function( path, type, mode ) { + var fs = __webpack_require__(8); + var fd = fs.openSync( path, mode[0] ); + if( mode === "read" && !fs.existsSync( path ) ) + return null; + return { + get: function( length, position ) { + var buffer = new Buffer( length ); + fs.readSync( fd, buffer, 0, length, position ); + return buffer.toString(); + }, + put: function( text, position ) { + var buffer = Buffer.from( text ); + if( position === "end_of_file" ) + fs.writeSync( fd, buffer ); + else if( position === "past_end_of_file" ) + return null; + else + fs.writeSync( fd, buffer, 0, buffer.length, position ); + return true; + }, + get_byte: function( position ) { + return null; + }, + put_byte: function( byte, position ) { + return null; + }, + flush: function() { + return true; + }, + close: function() { + fs.closeSync( fd ); + return true; + } + }; + } + }; + + // User input for Node.js + nodejs_user_input = { + buffer: "", + get: function( length, _ ) { + var text; + var readlineSync = __webpack_require__(9); + while( nodejs_user_input.buffer.length < length ) + nodejs_user_input.buffer += readlineSync.question(); + text = nodejs_user_input.buffer.substr( 0, length ); + nodejs_user_input.buffer = nodejs_user_input.buffer.substr( length ); + return text; + } + }; + + // User output for Node.js + nodejs_user_output = { + put: function( text, _ ) { + process.stdout.write( text ); + return true; + }, + flush: function() { + return true; + } + }; + + + + // PARSER + + var indexOf; + if(!Array.prototype.indexOf) { + indexOf = function(array, elem) { + var len = array.length; + for(var i = 0; i < len; i++) { + if(elem === array[i]) return i; + } + return -1; + }; + } else { + indexOf = function(array, elem) { + return array.indexOf(elem); + }; + } + + var reduce = function(array, fn) { + if(array.length === 0) return undefined; + var elem = array[0]; + var len = array.length; + for(var i = 1; i < len; i++) { + elem = fn(elem, array[i]); + } + return elem; + }; + + var map; + if(!Array.prototype.map) { + map = function(array, fn) { + var a = []; + var len = array.length; + for(var i = 0; i < len; i++) { + a.push( fn(array[i]) ); + } + return a; + }; + } else { + map = function(array, fn) { + return array.map(fn); + }; + } + + var filter; + if(!Array.prototype.filter) { + filter = function(array, fn) { + var a = []; + var len = array.length; + for(var i = 0; i < len; i++) { + if(fn(array[i])) + a.push( array[i] ); + } + return a; + }; + } else { + filter = function(array, fn) { + return array.filter(fn); + }; + } + + var codePointAt; + if(!String.prototype.codePointAt) { + codePointAt = function(str, i) { + return str.charCodeAt(i); + }; + } else { + codePointAt = function(str, i) { + return str.codePointAt(i); + }; + } + + var fromCodePoint; + if(!String.fromCodePoint) { + fromCodePoint = function() { + return String.fromCharCode.apply(null, arguments); + }; + } else { + fromCodePoint = function() { + return String.fromCodePoint.apply(null, arguments); + }; + } + + + + var ERROR = 0; + var SUCCESS = 1; + + var regex_escape = /(\\a)|(\\b)|(\\f)|(\\n)|(\\r)|(\\t)|(\\v)|\\x([0-9a-fA-F]+)\\|\\([0-7]+)\\|(\\\\)|(\\')|('')|(\\")|(\\`)|(\\.)|(.)/g; + var escape_map = {"\\a": 7, "\\b": 8, "\\f": 12, "\\n": 10, "\\r": 13, "\\t": 9, "\\v": 11}; + function escape(str) { + var s = []; + var _error = false; + str.replace(regex_escape, function(match, a, b, f, n, r, t, v, hex, octal, back, single, dsingle, double, backquote, error, char) { + switch(true) { + case hex !== undefined: + s.push( parseInt(hex, 16) ); + return ""; + case octal !== undefined: + s.push( parseInt(octal, 8) ); + return ""; + case back !== undefined: + case single !== undefined: + case dsingle !== undefined: + case double !== undefined: + case backquote !== undefined: + s.push( codePointAt(match.substr(1),0) ); + return ""; + case char !== undefined: + s.push( codePointAt(char,0) ); + return ""; + case error !== undefined: + _error = true; + default: + s.push(escape_map[match]); + return ""; + } + }); + if(_error) + return null; + return s; + } + + // Escape atoms + function escapeAtom(str, quote) { + var atom = ''; + if( str.length < 2 ) return str; + try { + str = str.replace(/\\([0-7]+)\\/g, function(match, g1) { + return fromCodePoint(parseInt(g1, 8)); + }); + str = str.replace(/\\x([0-9a-fA-F]+)\\/g, function(match, g1) { + return fromCodePoint(parseInt(g1, 16)); + }); + } catch(error) { + return null; + } + for( var i = 0; i < str.length; i++) { + var a = str.charAt(i); + var b = str.charAt(i+1); + if( a === quote && b === quote ) { + i++; + atom += quote; + } else if( a === '\\' ) { + if( ['a','b','f','n','r','t','v',"'",'"','\\','\a','\b','\f','\n','\r','\t','\v'].indexOf(b) !== -1 ) { + i += 1; + switch( b ) { + case 'a': atom += '\a'; break; + case 'b': atom += '\b'; break; + case 'f': atom += '\f'; break; + case 'n': atom += '\n'; break; + case 'r': atom += '\r'; break; + case 't': atom += '\t'; break; + case 'v': atom += '\v'; break; + case "'": atom += "'"; break; + case '"': atom += '"'; break; + case '\\': atom += '\\'; break; + } + } else { + return null; + } + } else { + atom += a; + } + } + return atom; + } + + // Redo escape + function redoEscape(str) { + var atom = ''; + for( var i = 0; i < str.length; i++) { + switch( str.charAt(i) ) { + case "'": atom += "\\'"; break; + case '\\': atom += '\\\\'; break; + //case '\a': atom += '\\a'; break; + case '\b': atom += '\\b'; break; + case '\f': atom += '\\f'; break; + case '\n': atom += '\\n'; break; + case '\r': atom += '\\r'; break; + case '\t': atom += '\\t'; break; + case '\v': atom += '\\v'; break; + default: atom += str.charAt(i); break; + } + } + return atom; + } + + // String to num + function convertNum(num) { + var n = num.substr(2); + switch(num.substr(0,2).toLowerCase()) { + case "0x": + return parseInt(n, 16); + case "0b": + return parseInt(n, 2); + case "0o": + return parseInt(n, 8); + case "0'": + return escape(n)[0]; + default: + return parseFloat(num); + } + } + + // Regular expressions for tokens + var rules = { + whitespace: /^\s*(?:(?:%.*)|(?:\/\*(?:\n|\r|.)*?\*\/)|(?:\s+))\s*/, + variable: /^(?:[A-Z_][a-zA-Z0-9_]*)/, + atom: /^(\!|,|;|[a-z][0-9a-zA-Z_]*|[#\$\&\*\+\-\.\/\:\<\=\>\?\@\^\~\\]+|'(?:[^']*?(?:\\(?:x?\d+)?\\)*(?:'')*(?:\\')*)*')/, + number: /^(?:0o[0-7]+|0x[0-9a-fA-F]+|0b[01]+|0'(?:''|\\[abfnrtv\\'"`]|\\x?\d+\\|[^\\])|\d+(?:\.\d+(?:[eE][+-]?\d+)?)?)/, + string: /^(?:"([^"]|""|\\")*"|`([^`]|``|\\`)*`)/, + l_brace: /^(?:\[)/, + r_brace: /^(?:\])/, + l_bracket: /^(?:\{)/, + r_bracket: /^(?:\})/, + bar: /^(?:\|)/, + l_paren: /^(?:\()/, + r_paren: /^(?:\))/ + }; + + // Replace chars of char_conversion session + function replace( thread, text ) { + if( thread.get_flag( "char_conversion" ).id === "on" ) { + return text.replace(/./g, function(char) { + return thread.get_char_conversion( char ); + }); + } + return text; + } + + // Tokenize strings + function Tokenizer(thread) { + this.thread = thread; + this.text = ""; // Current text to be analized + this.tokens = []; // Consumed tokens + } + + Tokenizer.prototype.set_last_tokens = function(tokens) { + return this.tokens = tokens; + }; + + Tokenizer.prototype.new_text = function(text) { + this.text = text; + this.tokens = []; + }; + + Tokenizer.prototype.get_tokens = function(init) { + var text; + var len = 0; // Total length respect to text + var line = 0; + var start = 0; + var tokens = []; + var last_in_blank = false; + + if(init) { + var token = this.tokens[init-1]; + len = token.len; + text = replace( this.thread, this.text.substr(token.len) ); + line = token.line; + start = token.start; + } + else + text = this.text; + + + // If there is nothing to be analized, return null + if(/^\s*$/.test(text)) + return null; + + while(text !== "") { + var matches = []; + var last_is_blank = false; + + if(/^\n/.exec(text) !== null) { + line++; + start = 0; + len++; + text = text.replace(/\n/, ""); + last_in_blank = true; + continue; + } + + for(var rule in rules) { + if(rules.hasOwnProperty(rule)) { + var matchs = rules[rule].exec( text ); + if(matchs) { + matches.push({ + value: matchs[0], + name: rule, + matches: matchs + }); + } + } + } + + // Lexical error + if(!matches.length) + return this.set_last_tokens( [{ value: text, matches: [], name: "lexical", line: line, start: start }] ); + + var token = reduce( matches, function(a, b) { + return a.value.length >= b.value.length ? a : b; + } ); + + token.start = start; + token.line = line; + + text = text.replace(token.value, ""); + start += token.value.length; + len += token.value.length; + + switch(token.name) { + case "atom": + token.raw = token.value; + if(token.value.charAt(0) === "'") { + token.value = escapeAtom( token.value.substr(1, token.value.length - 2), "'" ); + if( token.value === null ) { + token.name = "lexical"; + token.value = "unknown escape sequence"; + } + } + break; + case "number": + token.float = token.value.substring(0,2) !== "0x" && token.value.match(/[.eE]/) !== null && token.value !== "0'."; + token.value = convertNum( token.value ); + token.blank = last_is_blank; + break; + case "string": + var del = token.value.charAt(0); + token.value = escapeAtom( token.value.substr(1, token.value.length - 2), del ); + if( token.value === null ) { + token.name = "lexical"; + token.value = "unknown escape sequence"; + } + break; + case "whitespace": + var last = tokens[tokens.length-1]; + if(last) last.space = true; + last_is_blank = true; + continue; + case "r_bracket": + if( tokens.length > 0 && tokens[tokens.length-1].name === "l_bracket" ) { + token = tokens.pop(); + token.name = "atom"; + token.value = "{}"; + token.raw = "{}"; + token.space = false; + } + break; + case "r_brace": + if( tokens.length > 0 && tokens[tokens.length-1].name === "l_brace" ) { + token = tokens.pop(); + token.name = "atom"; + token.value = "[]"; + token.raw = "[]"; + token.space = false; + } + break; + } + token.len = len; + tokens.push( token ); + last_is_blank = false; + } + + var t = this.set_last_tokens( tokens ); + return t.length === 0 ? null : t; + }; + + // Parse an expression + function parseExpr(thread, tokens, start, priority, toplevel) { + if(!tokens[start]) return {type: ERROR, value: pl.error.syntax(tokens[start-1], "expression expected", true)}; + var error; + + if(priority === "0") { + var token = tokens[start]; + switch(token.name) { + case "number": + return {type: SUCCESS, len: start+1, value: new pl.type.Num(token.value, token.float)}; + case "variable": + return {type: SUCCESS, len: start+1, value: new pl.type.Var(token.value)}; + case "string": + var str; + switch( thread.get_flag( "double_quotes" ).id ) { + case "atom":; + str = new Term( token.value, [] ); + break; + case "codes": + str = new Term( "[]", [] ); + for(var i = token.value.length-1; i >= 0; i-- ) + str = new Term( ".", [new pl.type.Num( codePointAt(token.value,i), false ), str] ); + break; + case "chars": + str = new Term( "[]", [] ); + for(var i = token.value.length-1; i >= 0; i-- ) + str = new Term( ".", [new pl.type.Term( token.value.charAt(i), [] ), str] ); + break; + } + return {type: SUCCESS, len: start+1, value: str}; + case "l_paren": + var expr = parseExpr(thread, tokens, start+1, thread.__get_max_priority(), true); + if(expr.type !== SUCCESS) return expr; + if(tokens[expr.len] && tokens[expr.len].name === "r_paren") { + expr.len++; + return expr; + } + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[expr.len] ? tokens[expr.len] : tokens[expr.len-1], ") or operator expected", !tokens[expr.len])} + case "l_bracket": + var expr = parseExpr(thread, tokens, start+1, thread.__get_max_priority(), true); + if(expr.type !== SUCCESS) return expr; + if(tokens[expr.len] && tokens[expr.len].name === "r_bracket") { + expr.len++; + expr.value = new Term( "{}", [expr.value] ); + return expr; + } + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[expr.len] ? tokens[expr.len] : tokens[expr.len-1], "} or operator expected", !tokens[expr.len])} + } + // Compound term + var result = parseTerm(thread, tokens, start, toplevel); + if(result.type === SUCCESS || result.derived) + return result; + // List + result = parseList(thread, tokens, start); + if(result.type === SUCCESS || result.derived) + return result; + // Unexpected + return {type: ERROR, derived: false, value: pl.error.syntax(tokens[start], "unexpected token")}; + } + + var max_priority = thread.__get_max_priority(); + var next_priority = thread.__get_next_priority(priority); + var aux_start = start; + + // Prefix operators + if(tokens[start].name === "atom" && tokens[start+1] && (tokens[start].space || tokens[start+1].name !== "l_paren")) { + var token = tokens[start++]; + var classes = thread.__lookup_operator_classes(priority, token.value); + + // Associative prefix operator + if(classes && classes.indexOf("fy") > -1) { + var expr = parseExpr(thread, tokens, start, priority, toplevel); + if(expr.type !== ERROR) { + if( token.value === "-" && !token.space && pl.type.is_number( expr.value ) ) { + return { + value: new pl.type.Num(-expr.value.value, expr.value.is_float), + len: expr.len, + type: SUCCESS + }; + } else { + return { + value: new pl.type.Term(token.value, [expr.value]), + len: expr.len, + type: SUCCESS + }; + } + } else { + error = expr; + } + // Non-associative prefix operator + } else if(classes && classes.indexOf("fx") > -1) { + var expr = parseExpr(thread, tokens, start, next_priority, toplevel); + if(expr.type !== ERROR) { + return { + value: new pl.type.Term(token.value, [expr.value]), + len: expr.len, + type: SUCCESS + }; + } else { + error = expr; + } + } + } + + start = aux_start; + var expr = parseExpr(thread, tokens, start, next_priority, toplevel); + if(expr.type === SUCCESS) { + start = expr.len; + var token = tokens[start]; + if(tokens[start] && ( + tokens[start].name === "atom" && thread.__lookup_operator_classes(priority, token.value) || + tokens[start].name === "bar" && thread.__lookup_operator_classes(priority, "|") + ) ) { + var next_priority_lt = next_priority; + var next_priority_eq = priority; + var classes = thread.__lookup_operator_classes(priority, token.value); + + if(classes.indexOf("xf") > -1) { + return { + value: new pl.type.Term(token.value, [expr.value]), + len: ++expr.len, + type: SUCCESS + }; + } else if(classes.indexOf("xfx") > -1) { + var expr2 = parseExpr(thread, tokens, start + 1, next_priority_lt, toplevel); + if(expr2.type === SUCCESS) { + return { + value: new pl.type.Term(token.value, [expr.value, expr2.value]), + len: expr2.len, + type: SUCCESS + }; + } else { + expr2.derived = true; + return expr2; + } + } else if(classes.indexOf("xfy") > -1) { + var expr2 = parseExpr(thread, tokens, start + 1, next_priority_eq, toplevel); + if(expr2.type === SUCCESS) { + return { + value: new pl.type.Term(token.value, [expr.value, expr2.value]), + len: expr2.len, + type: SUCCESS + }; + } else { + expr2.derived = true; + return expr2; + } + } else if(expr.type !== ERROR) { + while(true) { + start = expr.len; + var token = tokens[start]; + if(token && token.name === "atom" && thread.__lookup_operator_classes(priority, token.value)) { + var classes = thread.__lookup_operator_classes(priority, token.value); + if( classes.indexOf("yf") > -1 ) { + expr = { + value: new pl.type.Term(token.value, [expr.value]), + len: ++start, + type: SUCCESS + }; + } else if( classes.indexOf("yfx") > -1 ) { + var expr2 = parseExpr(thread, tokens, ++start, next_priority_lt, toplevel); + if(expr2.type === ERROR) { + expr2.derived = true; + return expr2; + } + start = expr2.len; + expr = { + value: new pl.type.Term(token.value, [expr.value, expr2.value]), + len: start, + type: SUCCESS + }; + } else { break; } + } else { break; } + } + } + } else { + error = {type: ERROR, value: pl.error.syntax(tokens[expr.len-1], "operator expected")}; + } + return expr; + } + return expr; + } + + // Parse a compound term + function parseTerm(thread, tokens, start, toplevel) { + if(!tokens[start] || (tokens[start].name === "atom" && tokens[start].raw === "." && !toplevel && (tokens[start].space || !tokens[start+1] || tokens[start+1].name !== "l_paren"))) + return {type: ERROR, derived: false, value: pl.error.syntax(tokens[start-1], "unfounded token")}; + var atom = tokens[start]; + var exprs = []; + if(tokens[start].name === "atom" && tokens[start].raw !== ",") { + start++; + if(tokens[start-1].space) return {type: SUCCESS, len: start, value: new pl.type.Term(atom.value, exprs)}; + if(tokens[start] && tokens[start].name === "l_paren") { + if(tokens[start+1] && tokens[start+1].name === "r_paren") + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start+1], "argument expected")}; + var expr = parseExpr(thread, tokens, ++start, "999", true); + if(expr.type === ERROR) { + if( expr.derived ) + return expr; + else + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start-1], "argument expected", !tokens[start])}; + } + exprs.push(expr.value); + start = expr.len; + while(tokens[start] && tokens[start].name === "atom" && tokens[start].value === ",") { + expr = parseExpr(thread, tokens, start+1, "999", true); + if(expr.type === ERROR) { + if( expr.derived ) + return expr; + else + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start+1] ? tokens[start+1] : tokens[start], "argument expected", !tokens[start+1])}; + } + exprs.push(expr.value); + start = expr.len; + } + if(tokens[start] && tokens[start].name === "r_paren") start++; + else return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start-1], ", or ) expected", !tokens[start])}; + } + return {type: SUCCESS, len: start, value: new pl.type.Term(atom.value, exprs)}; + } + return {type: ERROR, derived: false, value: pl.error.syntax(tokens[start], "term expected")}; + } + + // Parse a list + function parseList(thread, tokens, start) { + if(!tokens[start]) + return {type: ERROR, derived: false, value: pl.error.syntax(tokens[start-1], "[ expected")}; + if(tokens[start] && tokens[start].name === "l_brace") { + var expr = parseExpr(thread, tokens, ++start, "999", true); + var exprs = [expr.value]; + var cons = undefined; + + if(expr.type === ERROR) { + if(tokens[start] && tokens[start].name === "r_brace") { + return {type: SUCCESS, len: start+1, value: new pl.type.Term("[]", [])}; + } + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start], "] expected")}; + } + + start = expr.len; + + while(tokens[start] && tokens[start].name === "atom" && tokens[start].value === ",") { + expr = parseExpr(thread, tokens, start+1, "999", true); + if(expr.type === ERROR) { + if( expr.derived ) + return expr; + else + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start+1] ? tokens[start+1] : tokens[start], "argument expected", !tokens[start+1])}; + } + exprs.push(expr.value); + start = expr.len; + } + var bar = false + if(tokens[start] && tokens[start].name === "bar") { + bar = true; + expr = parseExpr(thread, tokens, start+1, "999", true); + if(expr.type === ERROR) { + if( expr.derived ) + return expr; + else + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start+1] ? tokens[start+1] : tokens[start], "argument expected", !tokens[start+1])}; + } + cons = expr.value; + start = expr.len; + } + if(tokens[start] && tokens[start].name === "r_brace") + return {type: SUCCESS, len: start+1, value: arrayToList(exprs, cons) }; + else + return {type: ERROR, derived: true, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start-1], bar ? "] expected" : ", or | or ] expected", !tokens[start])}; + } + return {type: ERROR, derived: false, value: pl.error.syntax(tokens[start], "list expected")}; + } + + // Parse a rule + function parseRule(thread, tokens, start) { + var line = tokens[start].line; + var expr = parseExpr(thread, tokens, start, thread.__get_max_priority(), false); + var rule = null; + var obj; + if(expr.type !== ERROR) { + start = expr.len; + if(tokens[start] && tokens[start].name === "atom" && tokens[start].raw === ".") { + start++; + if( pl.type.is_term(expr.value) ) { + if(expr.value.indicator === ":-/2") { + rule = new pl.type.Rule(expr.value.args[0], body_conversion(expr.value.args[1])) + obj = { + value: rule, + len: start, + type: SUCCESS + }; + } else if(expr.value.indicator === "-->/2") { + rule = rule_to_dcg(new pl.type.Rule(expr.value.args[0], expr.value.args[1]), thread); + rule.body = body_conversion( rule.body ); + obj = { + value: rule, + len: start, + type: pl.type.is_rule( rule ) ? SUCCESS : ERROR + }; + } else { + rule = new pl.type.Rule(expr.value, null); + obj = { + value: rule, + len: start, + type: SUCCESS + }; + } + if( rule ) { + var singleton = rule.singleton_variables(); + if( singleton.length > 0 ) + thread.throw_warning( pl.warning.singleton( singleton, rule.head.indicator, line ) ); + } + return obj; + } else { + return { type: ERROR, value: pl.error.syntax(tokens[start], "callable expected") }; + } + } else { + return { type: ERROR, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start-1], ". or operator expected") }; + } + } + return expr; + } + + // Parse a program + function parseProgram(thread, string, options) { + options = options ? options : {}; + options.from = options.from ? options.from : "$tau-js"; + options.reconsult = options.reconsult !== undefined ? options.reconsult : true; + var tokenizer = new Tokenizer( thread ); + var reconsulted = {}; + var indicator; + tokenizer.new_text( string ); + var n = 0; + var tokens = tokenizer.get_tokens( n ); + do { + if( tokens === null || !tokens[n] ) break; + var expr = parseRule(thread, tokens, n); + if( expr.type === ERROR ) { + return new Term("throw", [expr.value]); + } else if(expr.value.body === null && expr.value.head.indicator === "?-/1") { + var n_thread = new Thread( thread.session ); + n_thread.add_goal( expr.value.head.args[0] ); + n_thread.answer( function( answer ) { + if( pl.type.is_error( answer ) ) { + thread.throw_warning( answer.args[0] ); + } else if( answer === false || answer === null ) { + thread.throw_warning( pl.warning.failed_goal( expr.value.head.args[0], expr.len ) ); + } + } ); + n = expr.len; + var result = true; + } else if(expr.value.body === null && expr.value.head.indicator === ":-/1") { + var result = thread.run_directive(expr.value.head.args[0]); + n = expr.len; + if(expr.value.head.args[0].indicator === "char_conversion/2") { + tokens = tokenizer.get_tokens( n ); + n = 0; + } + } else { + indicator = expr.value.head.indicator; + if( options.reconsult !== false && reconsulted[indicator] !== true && !thread.is_multifile_predicate( indicator ) ) { + thread.session.rules[indicator] = filter( thread.session.rules[indicator] || [], function( rule ) { return rule.dynamic; } ); + reconsulted[indicator] = true; + } + var result = thread.add_rule(expr.value, options); + n = expr.len; + } + if(!result) { + return result; + } + } while( true ); + return true; + } + + // Parse a query + function parseQuery(thread, string) { + var tokenizer = new Tokenizer( thread ); + tokenizer.new_text( string ); + var n = 0; + do { + var tokens = tokenizer.get_tokens( n ); + if( tokens === null ) break; + var expr = parseExpr(thread, tokens, 0, thread.__get_max_priority(), false); + if(expr.type !== ERROR) { + var expr_position = expr.len; + var tokens_pos = expr_position; + if(tokens[expr_position] && tokens[expr_position].name === "atom" && tokens[expr_position].raw === ".") { + thread.add_goal( body_conversion(expr.value) ); + } else { + var token = tokens[expr_position]; + return new Term("throw", [pl.error.syntax(token ? token : tokens[expr_position-1], ". or operator expected", !token)] ); + } + + n = expr.len + 1; + } else { + return new Term("throw", [expr.value]); + } + } while( true ); + return true; + } + + + + // UTILS + + // Rule to DCG + function rule_to_dcg(rule, thread) { + rule = rule.rename( thread ); + var begin = thread.next_free_variable(); + var dcg = body_to_dcg( rule.body, begin, thread ); + if( dcg.error ) return dcg.value; + rule.body = dcg.value; + rule.head.args = rule.head.args.concat([begin,dcg.variable]); + rule.head = new Term(rule.head.id, rule.head.args); + return rule; + } + + // Body to DCG + function body_to_dcg(expr, last, thread) { + var free; + if( pl.type.is_term( expr ) && expr.indicator === "!/0" ) { + return { + value: expr, + variable: last, + error: false + }; + } else if( pl.type.is_term( expr ) && expr.indicator === ",/2" ) { + var left = body_to_dcg(expr.args[0], last, thread); + if( left.error ) return left; + var right = body_to_dcg(expr.args[1], left.variable, thread); + if( right.error ) return right; + return { + value: new Term(',', [left.value, right.value]), + variable: right.variable, + error: false + }; + } else if( pl.type.is_term( expr ) && expr.indicator === "{}/1" ) { + return { + value: expr.args[0], + variable: last, + error: false + }; + } else if( pl.type.is_empty_list( expr ) ) { + return { + value: new Term("true", []), + variable: last, + error: false + }; + } else if( pl.type.is_list( expr ) ) { + free = thread.next_free_variable(); + var pointer = expr; + var prev; + while( pointer.indicator === "./2" ) { + prev = pointer; + pointer = pointer.args[1]; + } + if( pl.type.is_variable( pointer ) ) { + return { + value: pl.error.instantiation("DCG"), + variable: last, + error: true + }; + } else if( !pl.type.is_empty_list( pointer ) ) { + return { + value: pl.error.type("list", expr, "DCG"), + variable: last, + error: true + }; + } else { + prev.args[1] = free; + return { + value: new Term("=", [last, expr]), + variable: free, + error: false + }; + } + } else if( pl.type.is_callable( expr ) ) { + free = thread.next_free_variable(); + expr.args = expr.args.concat([last,free]); + expr = new Term( expr.id, expr.args ); + return { + value: expr, + variable: free, + error: false + }; + } else { + return { + value: pl.error.type( "callable", expr, "DCG" ), + variable: last, + error: true + }; + } + } + + // Body conversion + function body_conversion( expr ) { + if( pl.type.is_variable( expr ) ) + return new Term( "call", [expr] ); + else if( pl.type.is_term( expr ) && [",/2", ";/2", "->/2"].indexOf(expr.indicator) !== -1 ) + return new Term( expr.id, [body_conversion( expr.args[0] ), body_conversion( expr.args[1] )] ); + return expr; + } + + // List to Prolog list + function arrayToList( array, cons ) { + var list = cons ? cons : new pl.type.Term( "[]", [] ); + for(var i = array.length-1; i >= 0; i-- ) + list = new pl.type.Term( ".", [array[i], list] ); + return list; + } + + // Remove element from array + function remove( array, element ) { + for( var i = array.length - 1; i >= 0; i-- ) { + if( array[i] === element ) { + array.splice(i, 1); + } + } + } + + // Remove duplicate elements + function nub( array ) { + var seen = {}; + var unique = []; + for( var i = 0; i < array.length; i++ ) { + if( !(array[i] in seen) ) { + unique.push( array[i] ); + seen[array[i]] = true; + } + } + return unique; + } + + // Retract a rule + function retract( thread, point, indicator, rule ) { + if( thread.session.rules[indicator] !== null ) { + for( var i = 0; i < thread.session.rules[indicator].length; i++ ) { + if( thread.session.rules[indicator][i] === rule ) { + thread.session.rules[indicator].splice( i, 1 ); + thread.success( point ); + break; + } + } + } + } + + // call/n + function callN( n ) { + return function ( thread, point, atom ) { + var closure = atom.args[0], args = atom.args.slice(1, n); + if( pl.type.is_variable( closure ) ) { + thread.throw_error( pl.error.instantiation( thread.level ) ); + } else if( !pl.type.is_callable( closure ) ) { + thread.throw_error( pl.error.type( "callable", closure, thread.level ) ); + } else { + var goal = new Term( closure.id, closure.args.concat( args ) ); + thread.prepend( [new State( point.goal.replace( goal ), point.substitution, point )] ); + } + }; + } + + // String to indicator + function str_indicator( str ) { + for( var i = str.length - 1; i >= 0; i-- ) + if( str.charAt(i) === "/" ) + return new Term( "/", [new Term( str.substring(0, i) ), new Num( parseInt(str.substring(i+1)), false )] ); + } + + + + // PROLOG OBJECTS + + // Variables + function Var( id ) { + this.id = id; + } + + // Numbers + function Num( value, is_float ) { + this.is_float = is_float !== undefined ? is_float : parseInt( value ) !== value; + this.value = this.is_float ? value : parseInt( value ); + } + + // Terms + var term_ref = 0; + function Term( id, args, ref ) { + this.ref = ref || ++term_ref; + this.id = id; + this.args = args || []; + this.indicator = id + "/" + this.args.length; + } + + // Streams + var stream_ref = 0; + function Stream( stream, mode, alias, type, reposition, eof_action ) { + this.id = stream_ref++; + this.stream = stream; + this.mode = mode; // "read" or "write" or "append" + this.alias = alias; + this.type = type !== undefined ? type : "text"; // "text" or "binary" + this.reposition = reposition !== undefined ? reposition : true; // true or false + this.eof_action = eof_action !== undefined ? eof_action : "eof_code"; // "error" or "eof_code" or "reset" + this.position = this.mode === "append" ? "end_of_stream" : 0; + this.output = this.mode === "write" || this.mode === "append"; + this.input = this.mode === "read"; + } + + // Substitutions + function Substitution( links ) { + links = links || {}; + this.links = links; + } + + // States + function State( goal, subs, parent ) { + subs = subs || new Substitution(); + parent = parent || null; + this.goal = goal; + this.substitution = subs; + this.parent = parent; + } + + // Rules + function Rule( head, body, dynamic ) { + this.head = head; + this.body = body; + this.dynamic = dynamic ? dynamic : false; + } + + // Session + function Session( limit ) { + limit = limit === undefined || limit <= 0 ? 1000 : limit; + this.rules = {}; + this.src_predicates = {}; + this.rename = 0; + this.modules = []; + this.thread = new Thread( this ); + this.total_threads = 1; + this.renamed_variables = {}; + this.public_predicates = {}; + this.multifile_predicates = {}; + this.limit = limit; + this.streams = { + "user_input": new Stream( + true && module.exports ? nodejs_user_input : tau_user_input, + "read", "user_input", "text", false, "reset" ), + "user_output": new Stream( + true && module.exports ? nodejs_user_output : tau_user_output, + "write", "user_output", "text", false, "eof_code" ) + }; + this.file_system = true && module.exports ? nodejs_file_system : tau_file_system; + this.standard_input = this.streams["user_input"]; + this.standard_output = this.streams["user_output"]; + this.current_input = this.streams["user_input"]; + this.current_output = this.streams["user_output"]; + this.format_success = function( state ) { return state.substitution; }; + this.format_error = function( state ) { return state.goal; }; + this.flag = { + bounded: pl.flag.bounded.value, + max_integer: pl.flag.max_integer.value, + min_integer: pl.flag.min_integer.value, + integer_rounding_function: pl.flag.integer_rounding_function.value, + char_conversion: pl.flag.char_conversion.value, + debug: pl.flag.debug.value, + max_arity: pl.flag.max_arity.value, + unknown: pl.flag.unknown.value, + double_quotes: pl.flag.double_quotes.value, + occurs_check: pl.flag.occurs_check.value, + dialect: pl.flag.dialect.value, + version_data: pl.flag.version_data.value, + nodejs: pl.flag.nodejs.value + }; + this.__loaded_modules = []; + this.__char_conversion = {}; + this.__operators = { + 1200: { ":-": ["fx", "xfx"], "-->": ["xfx"], "?-": ["fx"] }, + 1100: { ";": ["xfy"] }, + 1050: { "->": ["xfy"] }, + 1000: { ",": ["xfy"] }, + 900: { "\\+": ["fy"] }, + 700: { + "=": ["xfx"], "\\=": ["xfx"], "==": ["xfx"], "\\==": ["xfx"], + "@<": ["xfx"], "@=<": ["xfx"], "@>": ["xfx"], "@>=": ["xfx"], + "=..": ["xfx"], "is": ["xfx"], "=:=": ["xfx"], "=\\=": ["xfx"], + "<": ["xfx"], "=<": ["xfx"], ">": ["xfx"], ">=": ["xfx"] + }, + 600: { ":": ["xfy"] }, + 500: { "+": ["yfx"], "-": ["yfx"], "/\\": ["yfx"], "\\/": ["yfx"] }, + 400: { + "*": ["yfx"], "/": ["yfx"], "//": ["yfx"], "rem": ["yfx"], + "mod": ["yfx"], "<<": ["yfx"], ">>": ["yfx"] + }, + 200: { "**": ["xfx"], "^": ["xfy"], "-": ["fy"], "+": ["fy"], "\\": ["fy"] } + }; + } + + // Threads + function Thread( session ) { + this.epoch = Date.now(); + this.session = session; + this.session.total_threads++; + this.total_steps = 0; + this.cpu_time = 0; + this.cpu_time_last = 0; + this.points = []; + this.debugger = false; + this.debugger_states = []; + this.level = "top_level/0"; + this.__calls = []; + this.current_limit = this.session.limit; + this.warnings = []; + } + + // Modules + function Module( id, rules, exports ) { + this.id = id; + this.rules = rules; + this.exports = exports; + pl.module[id] = this; + } + + Module.prototype.exports_predicate = function( indicator ) { + return this.exports.indexOf( indicator ) !== -1; + }; + + + + // UNIFY PROLOG OBJECTS + + // Variables + Var.prototype.unify = function( obj, occurs_check ) { + if( occurs_check && indexOf( obj.variables(), this.id ) !== -1 && !pl.type.is_variable( obj ) ) { + return null; + } + var links = {}; + links[this.id] = obj; + return new Substitution( links ); + }; + + // Numbers + Num.prototype.unify = function( obj, _ ) { + if( pl.type.is_number( obj ) && this.value === obj.value && this.is_float === obj.is_float ) { + return new Substitution(); + } + return null; + }; + + // Terms + Term.prototype.unify = function( obj, occurs_check ) { + if( pl.type.is_term( obj ) && this.indicator === obj.indicator ) { + var subs = new Substitution(); + for( var i = 0; i < this.args.length; i++ ) { + var mgu = pl.unify( this.args[i].apply( subs ), obj.args[i].apply( subs ), occurs_check ); + if( mgu === null ) + return null; + for( var x in mgu.links ) + subs.links[x] = mgu.links[x]; + subs = subs.apply( mgu ); + } + return subs; + } + return null; + }; + + // Streams + Stream.prototype.unify = function( obj, occurs_check ) { + if( pl.type.is_stream( obj ) && this.id === obj.id ) { + return new Substitution(); + } + return null; + }; + + + + // PROLOG OBJECTS TO STRING + + // Variables + Var.prototype.toString = function( _ ) { + return this.id; + }; + + // Numbers + Num.prototype.toString = function( _ ) { + return this.is_float && indexOf(this.value.toString(), ".") === -1 ? this.value + ".0" : this.value.toString(); + }; + + // Terms + Term.prototype.toString = function( options, priority, from ) { + options = !options ? {} : options; + options.quoted = options.quoted === undefined ? true: options.quoted; + options.ignore_ops = options.ignore_ops === undefined ? false : options.ignore_ops; + options.numbervars = options.numbervars === undefined ? false : options.numbervars; + priority = priority === undefined ? 1200 : priority; + from = from === undefined ? "" : from; + if( options.numbervars && this.indicator === "$VAR/1" && pl.type.is_integer( this.args[0] ) && this.args[0].value >= 0 ) { + var i = this.args[0].value; + var number = Math.floor( i/26 ); + var letter = i % 26; + return "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[letter] + (number !== 0 ? number : ""); + } + switch( this.indicator ){ + case "[]/0": + case "{}/0": + case "!/0": + return this.id; + case "{}/1": + return "{" + this.args[0].toString( options ) + "}"; + case "./2": + var list = "[" + this.args[0].toString( options ); + var pointer = this.args[1]; + while( pointer.indicator === "./2" ) { + list += ", " + pointer.args[0].toString( options ); + pointer = pointer.args[1]; + } + if( pointer.indicator !== "[]/0" ) { + list += "|" + pointer.toString( options ); + } + list += "]"; + return list; + case ",/2": + return "(" + this.args[0].toString( options ) + ", " + this.args[1].toString( options ) + ")"; + default: + var id = this.id; + var operator = options.session ? options.session.lookup_operator( this.id, this.args.length ) : null; + if( options.session === undefined || options.ignore_ops || operator === null ) { + if( options.quoted && ! /^(!|,|;|[a-z][0-9a-zA-Z_]*)$/.test( id ) && id !== "{}" && id !== "[]" ) + id = "'" + redoEscape(id) + "'"; + return id + (this.args.length ? "(" + map( this.args, + function(x) { return x.toString( options); } + ).join(", ") + ")" : ""); + } else { + var cond = operator.priority > priority.priority || operator.priority === priority.priority && ( + operator.class === "xfy" && this.indicator !== priority.indicator || + operator.class === "yfx" && this.indicator !== priority.indicator || + this.indicator === priority.indicator && operator.class === "yfx" && from === "right" || + this.indicator === priority.indicator && operator.class === "xfy" && from === "left"); + operator.indicator = this.indicator; + var lpar = cond ? "(" : ""; + var rpar = cond ? ")" : ""; + if( this.args.length === 0 ) { + return "(" + this.id + ")"; + } else if( ["fy","fx"].indexOf( operator.class) !== -1 ) { + return lpar + id + " " + this.args[0].toString( options, operator ) + rpar; + } else if( ["yf","xf"].indexOf( operator.class) !== -1 ) { + return lpar + this.args[0].toString( options, operator ) + " " + id + rpar; + } else { + return lpar + this.args[0].toString( options, operator, "left" ) + " " + this.id + " " + this.args[1].toString( options, operator, "right" ) + rpar; + } + } + } + }; + + // Streams + Stream.prototype.toString = function( _ ) { + return "(" + this.id + ")"; + }; + + // Substitutions + Substitution.prototype.toString = function( options ) { + var str = "{"; + for( var link in this.links ) { + if(!this.links.hasOwnProperty(link)) continue; + if( str !== "{" ) { + str += ", "; + } + str += link + "/" + this.links[link].toString( options ); + } + str += "}"; + return str; + }; + + // States + State.prototype.toString = function( options ) { + if( this.goal === null ) { + return "<" + this.substitution.toString( options ) + ">"; + } else { + return "<" + this.goal.toString( options ) + ", " + this.substitution.toString( options ) + ">"; + } + }; + + // Rules + Rule.prototype.toString = function( options ) { + if( !this.body ) { + return this.head.toString( options ) + "."; + } else { + return this.head.toString( options ) + " :- " + this.body.toString( options ) + "."; + } + }; + + // Session + Session.prototype.toString = function( options ) { + var str = ""; + for(var i = 0; i < this.modules.length; i++) { + str += ":- use_module(library(" + this.modules[i] + ")).\n"; + } + str += "\n"; + for(key in this.rules) { + for(i = 0; i < this.rules[key].length; i++) { + str += this.rules[key][i].toString( options ); + str += "\n"; + } + } + return str; + }; + + + + // CLONE PROLOG OBJECTS + + // Variables + Var.prototype.clone = function() { + return new Var( this.id ); + }; + + // Numbers + Num.prototype.clone = function() { + return new Num( this.value, this.is_float ); + }; + + // Terms + Term.prototype.clone = function() { + return new Term( this.id, map( this.args, function( arg ) { + return arg.clone(); + } ) ); + }; + + // Streams + Stream.prototype.clone = function() { + return new Stram( this.stream, this.mode, this.alias, this.type, this.reposition, this.eof_action ); + }; + + // Substitutions + Substitution.prototype.clone = function() { + var links = {}; + for( var link in this.links ) { + if(!this.links.hasOwnProperty(link)) continue; + links[link] = this.links[link].clone(); + } + return new Substitution( links ); + }; + + // States + State.prototype.clone = function() { + return new State( this.goal.clone(), this.substitution.clone(), this.parent ); + }; + + // Rules + Rule.prototype.clone = function() { + return new Rule( this.head.clone(), this.body !== null ? this.body.clone() : null ); + }; + + + + // COMPARE PROLOG OBJECTS + + // Variables + Var.prototype.equals = function( obj ) { + return pl.type.is_variable( obj ) && this.id === obj.id; + }; + + // Numbers + Num.prototype.equals = function( obj ) { + return pl.type.is_number( obj ) && this.value === obj.value && this.is_float === obj.is_float; + }; + + // Terms + Term.prototype.equals = function( obj ) { + if( !pl.type.is_term( obj ) || this.indicator !== obj.indicator ) { + return false; + } + for( var i = 0; i < this.args.length; i++ ) { + if( !this.args[i].equals( obj.args[i] ) ) { + return false; + } + } + return true; + }; + + // Streams + Stream.prototype.equals = function( obj ) { + return pl.type.is_stream( obj ) && this.id === obj.id; + }; + + // Substitutions + Substitution.prototype.equals = function( obj ) { + var link; + if( !pl.type.is_substitution( obj ) ) { + return false; + } + for( link in this.links ) { + if(!this.links.hasOwnProperty(link)) continue; + if( !obj.links[link] || !this.links[link].equals( obj.links[link] ) ) { + return false; + } + } + for( link in obj.links ) { + if(!obj.links.hasOwnProperty(link)) continue; + if( !this.links[link] ) { + return false; + } + } + return true; + }; + + // States + State.prototype.equals = function( obj ) { + return pl.type.is_state( obj ) && this.goal.equals( obj.goal ) && this.substitution.equals( obj.substitution ) && this.parent === obj.parent; + }; + + // Rules + Rule.prototype.equals = function( obj ) { + return pl.type.is_rule( obj ) && this.head.equals( obj.head ) && (this.body === null && obj.body === null || this.body !== null && this.body.equals( obj.body )); + }; + + + + // RENAME VARIABLES OF PROLOG OBJECTS + + // Variables + Var.prototype.rename = function( thread ) { + return thread.get_free_variable( this ); + }; + + // Numbers + Num.prototype.rename = function( _ ) { + return this; + }; + + // Terms + Term.prototype.rename = function( thread ) { + return new Term( this.id, map( this.args, function( arg ) { + return arg.rename( thread ); + } ) ); + }; + + // Streams + Stream.prototype.rename = function( thread ) { + return this; + }; + + // Rules + Rule.prototype.rename = function( thread ) { + return new Rule( this.head.rename( thread ), this.body !== null ? this.body.rename( thread ) : null ); + }; + + + + // GET VARIABLES FROM PROLOG OBJECTS + + // Variables + Var.prototype.variables = function() { + return [this.id]; + }; + + // Numbers + Num.prototype.variables = function() { + return []; + }; + + // Terms + Term.prototype.variables = function() { + return [].concat.apply( [], map( this.args, function( arg ) { + return arg.variables(); + } ) ); + }; + + // Streams + Stream.prototype.variables = function() { + return []; + }; + + // Rules + Rule.prototype.variables = function() { + if( this.body === null ) { + return this.head.variables(); + } else { + return this.head.variables().concat( this.body.variables() ); + } + }; + + + + // APPLY SUBSTITUTIONS TO PROLOG OBJECTS + + // Variables + Var.prototype.apply = function( subs ) { + if( subs.lookup( this.id ) ) { + return subs.lookup( this.id ); + } + return this; + }; + + // Numbers + Num.prototype.apply = function( _ ) { + return this; + }; + + // Terms + Term.prototype.apply = function( subs ) { + if( this.indicator === "./2" ) { + var arr = []; + var pointer = this; + while( pointer.indicator === "./2" ) { + arr.push( pointer.args[0].apply( subs ) ); + pointer = pointer.args[1]; + } + var list = pointer.apply( subs ); + for(var i = arr.length-1; i >= 0; i--) { + list = new Term( ".", [arr[i], list] ); + } + return list; + } + return new Term( this.id, map( this.args, function( arg ) { + return arg.apply( subs ); + } ), this.ref ); + }; + + // Streams + Stream.prototype.apply = function( _ ) { + return this; + }; + + // Rules + Rule.prototype.apply = function( subs ) { + return new Rule( this.head.apply( subs ), this.body !== null ? this.body.apply( subs ) : null ); + }; + + // Substitutions + Substitution.prototype.apply = function( subs ) { + var link, links = {}; + for( link in this.links ) { + if(!this.links.hasOwnProperty(link)) continue; + links[link] = this.links[link].apply(subs); + } + return new Substitution( links ); + }; + + + + // SELECTION FUNCTION + + // Select term + Term.prototype.select = function() { + var pointer = this; + while( pointer.indicator === ",/2" ) + pointer = pointer.args[0]; + return pointer; + }; + + // Replace term + Term.prototype.replace = function( expr ) { + if( this.indicator === ",/2" ) { + if( this.args[0].indicator === ",/2" ) { + return new Term( ",", [this.args[0].replace( expr ), this.args[1]] ); + } else { + return expr === null ? this.args[1] : new Term( ",", [expr, this.args[1]] ); + } + } else { + return expr; + } + }; + + // Search term + Term.prototype.search = function( expr ) { + if( pl.type.is_term( expr ) && expr.ref !== undefined && this.ref === expr.ref ) + return true; + for( var i = 0; i < this.args.length; i++ ) + if( pl.type.is_term( this.args[i] ) && this.args[i].search( expr ) ) + return true; + return false; + }; + + + + // PROLOG SESSIONS AND THREADS + + // Get current input + Session.prototype.get_current_input = function() { + return this.current_input; + }; + Thread.prototype.get_current_input = function() { + return this.session.get_current_input(); + }; + + // Get current output + Session.prototype.get_current_output = function() { + return this.current_output; + }; + Thread.prototype.get_current_output = function() { + return this.session.get_current_output(); + }; + + // Set current input + Session.prototype.set_current_input = function( input ) { + this.current_input = input; + }; + Thread.prototype.set_current_input = function( input ) { + return this.session.set_current_input( input ); + }; + + // Set current output + Session.prototype.set_current_output = function( output ) { + this.current_input = output; + }; + Thread.prototype.set_current_output = function( output ) { + return this.session.set_current_output( output); + }; + + // Get stream by alias + Session.prototype.get_stream_by_alias = function( alias ) { + return this.streams[alias]; + }; + Thread.prototype.get_stream_by_alias = function( alias ) { + return this.session.get_stream_by_alias( alias ); + }; + + // Open file + Session.prototype.file_system_open = function( path, type, mode ) { + return this.file_system.open( path, type, mode ); + }; + Thread.prototype.file_system_open = function( path, type, mode ) { + return this.session.file_system_open( path, type, mode ); + }; + + // Get conversion of the char + Session.prototype.get_char_conversion = function( char ) { + return this.__char_conversion[char] || char; + }; + Thread.prototype.get_char_conversion = function( char ) { + return this.session.get_char_conversion( char ); + }; + + // Parse an expression + Session.prototype.parse = function( string ) { + return this.thread.parse( string ); + }; + Thread.prototype.parse = function( string ) { + var tokenizer = new Tokenizer( this ); + tokenizer.new_text( string ); + var tokens = tokenizer.get_tokens(); + if( tokens === null ) + return false; + var expr = parseExpr(this, tokens, 0, this.__get_max_priority(), false); + if( expr.len !== tokens.length ) + return false; + return { value: expr.value, expr: expr, tokens: tokens }; + }; + + // Get flag value + Session.prototype.get_flag = function( flag ) { + return this.flag[flag]; + }; + Thread.prototype.get_flag = function( flag ) { + return this.session.get_flag( flag ); + }; + + // Add a rule + Session.prototype.add_rule = function( rule, options ) { + options = options ? options : {}; + options.from = options.from ? options.from : "$tau-js"; + this.src_predicates[rule.head.indicator] = options.from; + if(!this.rules[rule.head.indicator]) { + this.rules[rule.head.indicator] = []; + } + this.rules[rule.head.indicator].push(rule); + if( !this.public_predicates.hasOwnProperty( rule.head.indicator ) ) + this.public_predicates[rule.head.indicator] = false; + return true; + }; + Thread.prototype.add_rule = function( rule, options ) { + return this.session.add_rule( rule, options ); + }; + + // Run a directive + Session.prototype.run_directive = function( directive ) { + this.thread.run_directive( directive ); + }; + Thread.prototype.run_directive = function( directive ) { + if( pl.type.is_directive( directive ) ) { + pl.directive[directive.indicator]( this, directive ); + return true; + } + return false; + }; + + // Get maximum priority of the operators + Session.prototype.__get_max_priority = function() { + return "1200"; + }; + Thread.prototype.__get_max_priority = function() { + return this.session.__get_max_priority(); + }; + + // Get next priority of the operators + Session.prototype.__get_next_priority = function( priority ) { + var max = 0; + priority = parseInt( priority ); + for( var key in this.__operators ) { + if( !this.__operators.hasOwnProperty(key) ) continue; + var n = parseInt(key); + if( n > max && n < priority ) max = n; + } + return max.toString(); + }; + Thread.prototype.__get_next_priority = function( priority ) { + return this.session.__get_next_priority( priority ); + }; + + // Get classes of an operator + Session.prototype.__lookup_operator_classes = function( priority, operator ) { + if( this.__operators.hasOwnProperty( priority ) && this.__operators[priority][operator] instanceof Array ) { + return this.__operators[priority][operator] || false; + } + return false; + }; + Thread.prototype.__lookup_operator_classes = function( priority, operator ) { + return this.session.__lookup_operator_classes( priority, operator ); + }; + + // Get operator + Session.prototype.lookup_operator = function( name, arity ) { + for(var p in this.__operators) + if(this.__operators[p][name]) + for(var i = 0; i < this.__operators[p][name].length; i++) + if( arity === 0 || this.__operators[p][name][i].length === arity+1 ) + return {priority: p, class: this.__operators[p][name][i]}; + return null; + } + Thread.prototype.lookup_operator = function( name, arity ) { + return this.session.lookup_operator( name, arity ); + } + + // Throw a warning + Session.prototype.throw_warning = function( warning ) { + this.thread.throw_warning( warning ); + }; + Thread.prototype.throw_warning = function( warning ) { + this.warnings.push( warning ); + }; + + // Get warnings + Session.prototype.get_warnings = function() { + return this.thread.get_warnings(); + }; + Thread.prototype.get_warnings = function() { + return this.warnings; + }; + + // Add a goal + Session.prototype.add_goal = function( goal, unique ) { + this.thread.add_goal( goal, unique ); + }; + Thread.prototype.add_goal = function( goal, unique, parent ) { + parent = parent ? parent : null; + if( unique === true ) + this.points = []; + var vars = goal.variables(); + var links = {}; + for( var i = 0; i < vars.length; i++ ) + links[vars[i]] = new Var(vars[i]); + this.points.push( new State( goal, new Substitution(links), parent ) ); + }; + + // Consult a program from a string + Session.prototype.consult = function( program, options ) { + return this.thread.consult( program, options ); + }; + Thread.prototype.consult = function( program, options ) { + var string = ""; + if( typeof program === "string" ) { + string = program; + var len = string.length; + if( string.substring( len-3, len ) === ".pl" && document.getElementById( string ) ) { + var script = document.getElementById( string ); + var type = script.getAttribute( "type" ); + if( type !== null && type.replace( / /g, "" ).toLowerCase() === "text/prolog" ) { + string = script.text; + } + } + } else if( program.nodeName ) { + switch( program.nodeName.toLowerCase() ) { + case "input": + case "textarea": + string = program.value; + break; + default: + string = program.innerHTML; + break; + } + } else { + return false; + } + this.warnings = []; + return parseProgram( this, string, options ); + }; + + // Query goal from a string (without ?-) + Session.prototype.query = function( string ) { + return this.thread.query( string ); + }; + Thread.prototype.query = function( string ) { + this.points = []; + this.debugger_points = []; + return parseQuery( this, string ); + }; + + // Get first choice point + Session.prototype.head_point = function() { + return this.thread.head_point(); + }; + Thread.prototype.head_point = function() { + return this.points[this.points.length-1]; + }; + + // Get free variable + Session.prototype.get_free_variable = function( variable ) { + return this.thread.get_free_variable( variable ); + }; + Thread.prototype.get_free_variable = function( variable ) { + var variables = []; + if( variable.id === "_" || this.session.renamed_variables[variable.id] === undefined ) { + this.session.rename++; + if( this.points.length > 0 ) + variables = this.head_point().substitution.domain(); + while( indexOf( variables, pl.format_variable( this.session.rename ) ) !== -1 ) { + this.session.rename++; + } + if( variable.id === "_" ) { + return new Var( pl.format_variable( this.session.rename ) ); + } else { + this.session.renamed_variables[variable.id] = pl.format_variable( this.session.rename ); + } + } + return new Var( this.session.renamed_variables[variable.id] ); + }; + + // Get next free variable + Session.prototype.next_free_variable = function() { + return this.thread.next_free_variable(); + }; + Thread.prototype.next_free_variable = function() { + this.session.rename++; + var variables = []; + if( this.points.length > 0 ) + variables = this.head_point().substitution.domain(); + while( indexOf( variables, pl.format_variable( this.session.rename ) ) !== -1 ) { + this.session.rename++; + } + return new Var( pl.format_variable( this.session.rename ) ); + }; + + // Check if a predicate is public + Session.prototype.is_public_predicate = function( indicator ) { + return !this.public_predicates.hasOwnProperty( indicator ) || this.public_predicates[indicator] === true; + }; + Thread.prototype.is_public_predicate = function( indicator ) { + return this.session.is_public_predicate( indicator ); + }; + + // Check if a predicate is multifile + Session.prototype.is_multifile_predicate = function( indicator ) { + return this.multifile_predicates.hasOwnProperty( indicator ) && this.multifile_predicates[indicator] === true; + }; + Thread.prototype.is_multifile_predicate = function( indicator ) { + return this.session.is_multifile_predicate( indicator ); + }; + + // Insert states at the beginning + Session.prototype.prepend = function( states ) { + return this.thread.prepend( states ); + }; + Thread.prototype.prepend = function( states ) { + for(var i = states.length-1; i >= 0; i--) + this.points.push( states[i] ); + }; + + // Remove the selected term and prepend the current state + Session.prototype.success = function( point, parent ) { + return this.thread.success( point, parent ); + } + Thread.prototype.success = function( point, parent ) { + var parent = typeof parent === "undefined" ? point : parent; + this.prepend( [new State( point.goal.replace( null ), point.substitution, parent ) ] ); + }; + + // Throw error + Session.prototype.throw_error = function( error ) { + return this.thread.throw_error( error ); + }; + Thread.prototype.throw_error = function( error ) { + this.prepend( [new State( new Term( "throw", [error] ), new Substitution(), null, null )] ); + }; + + // Selection rule + Session.prototype.step_rule = function( mod, atom ) { + return this.thread.step_rule( mod, atom ); + } + Thread.prototype.step_rule = function( mod, atom ) { + var name = atom.indicator; + if( mod === "user" ) + mod = null; + if( mod === null && this.session.rules.hasOwnProperty(name) ) + return this.session.rules[name]; + var modules = mod === null ? this.session.modules : (indexOf(this.session.modules, mod) === -1 ? [] : [mod]); + for( var i = 0; i < modules.length; i++ ) { + var module = pl.module[modules[i]]; + if( module.rules.hasOwnProperty(name) && (module.rules.hasOwnProperty(this.level) || module.exports_predicate(name)) ) + return pl.module[modules[i]].rules[name]; + } + return null; + }; + + // Resolution step + Session.prototype.step = function() { + return this.thread.step(); + } + Thread.prototype.step = function() { + if( this.points.length === 0 ) { + return; + } + var asyn = false; + var point = this.points.pop(); + + if( this.debugger ) + this.debugger_states.push( point ); + + if( pl.type.is_term( point.goal ) ) { + + var atom = point.goal.select(); + var mod = null; + var states = []; + if( atom !== null ) { + + this.total_steps++; + var level = point; + while( level.parent !== null && level.parent.goal.search( atom ) ) + level = level.parent; + this.level = level.parent === null ? "top_level/0" : level.parent.goal.select().indicator; + + if( pl.type.is_term( atom ) && atom.indicator === ":/2" ) { + mod = atom.args[0].id; + atom = atom.args[1]; + } + + if( mod === null && pl.type.is_builtin( atom ) ) { + this.__call_indicator = atom.indicator; + asyn = pl.predicate[atom.indicator]( this, point, atom ); + } else { + var srule = this.step_rule(mod, atom); + if( srule === null ) { + if( !this.session.rules.hasOwnProperty( atom.indicator ) ) { + if( this.get_flag( "unknown" ).id === "error" ) { + this.throw_error( pl.error.existence( "procedure", atom.indicator, this.level ) ); + } else if( this.get_flag( "unknown" ).id === "warning" ) { + this.throw_warning( "unknown procedure " + atom.indicator + " (from " + this.level + ")" ); + } + } + } else if( srule instanceof Function ) { + asyn = srule( this, point, atom ); + } else { + for( var _rule in srule ) { + if(!srule.hasOwnProperty(_rule)) continue; + var rule = srule[_rule]; + this.session.renamed_variables = {}; + rule = rule.rename( this ); + var occurs_check = this.get_flag( "occurs_check" ).indicator === "true/0"; + var state = new State(); + var mgu = pl.unify( atom, rule.head, occurs_check ); + if( mgu !== null ) { + state.goal = point.goal.replace( rule.body ); + if( state.goal !== null ) { + state.goal = state.goal.apply( mgu ); + } + state.substitution = point.substitution.apply( mgu ); + state.parent = point; + states.push( state ); + } + } + this.prepend( states ); + } + } + } + } else if( pl.type.is_variable( point.goal ) ) { + this.throw_error( pl.error.instantiation( this.level ) ); + } else { + this.throw_error( pl.error.type( "callable", point.goal, this.level ) ); + } + return asyn; + }; + + // Find next computed answer + Session.prototype.answer = function( success ) { + return this.thread.answer( success ); + } + Thread.prototype.answer = function( success ) { + success = success || function( _ ) { }; + this.__calls.push( success ); + if( this.__calls.length > 1 ) { + return; + } + this.again(); + }; + + // Find all computed answers + Session.prototype.answers = function( callback, max, after ) { + return this.thread.answers( callback, max, after ); + } + Thread.prototype.answers = function( callback, max, after ) { + var answers = max || 1000; + var thread = this; + if( max <= 0 ) { + if(after) + after(); + return; + } + this.answer( function( answer ) { + callback( answer ); + if( answer !== false ) { + setTimeout( function() { + thread.answers( callback, max-1, after ); + }, 1 ); + } else if(after) { + after(); + } + } ); + }; + + // Again finding next computed answer + Session.prototype.again = function( reset_limit ) { + return this.thread.again( reset_limit ); + }; + Thread.prototype.again = function( reset_limit ) { + var answer; + var t0 = Date.now(); + while( this.__calls.length > 0 ) { + this.warnings = []; + if( reset_limit !== false ) + this.current_limit = this.session.limit; + while( this.current_limit > 0 && this.points.length > 0 && this.head_point().goal !== null && !pl.type.is_error( this.head_point().goal ) ) { + this.current_limit--; + if( this.step() === true ) { + return; + } + } + var t1 = Date.now(); + this.cpu_time_last = t1-t0; + this.cpu_time += this.cpu_time_last; + var success = this.__calls.shift(); + if( this.current_limit <= 0 ) { + success( null ); + } else if( this.points.length === 0 ) { + success( false ); + } else if( pl.type.is_error( this.head_point().goal ) ) { + answer = this.session.format_error( this.points.pop() ); + this.points = []; + success( answer ); + } else { + if( this.debugger ) + this.debugger_states.push( this.head_point() ); + answer = this.session.format_success( this.points.pop() ); + success( answer ); + } + } + }; + + // Unfolding transformation + Session.prototype.unfold = function( rule ) { + if(rule.body === null) + return false; + var head = rule.head; + var body = rule.body; + var atom = body.select(); + var thread = new Thread( this ); + var unfolded = []; + thread.add_goal( atom ); + thread.step(); + for( var i = thread.points.length-1; i >= 0; i-- ) { + var point = thread.points[i]; + var head2 = head.apply( point.substitution ); + var body2 = body.replace( point.goal ); + if( body2 !== null ) + body2 = body2.apply( point.substitution ); + unfolded.push( new Rule( head2, body2 ) ); + } + var rules = this.rules[head.indicator]; + var index = indexOf( rules, rule ); + if( unfolded.length > 0 && index !== -1 ) { + rules.splice.apply( rules, [index, 1].concat(unfolded) ); + return true; + } + return false; + }; + Thread.prototype.unfold = function(rule) { + return this.session.unfold(rule); + }; + + + + // INTERPRET EXPRESSIONS + + // Variables + Var.prototype.interpret = function( thread ) { + return pl.error.instantiation( thread.level ); + }; + + // Numbers + Num.prototype.interpret = function( thread ) { + return this; + }; + + // Terms + Term.prototype.interpret = function( thread ) { + if( pl.type.is_unitary_list( this ) ) { + return this.args[0].interpret( thread ); + } else { + return pl.operate( thread, this ); + } + }; + + + + // COMPARE PROLOG OBJECTS + + // Variables + Var.prototype.compare = function( obj ) { + if( this.id < obj.id ) { + return -1; + } else if( this.id > obj.id ) { + return 1; + } else { + return 0; + } + }; + + // Numbers + Num.prototype.compare = function( obj ) { + if( this.value === obj.value && this.is_float === obj.is_float ) { + return 0; + } else if( this.value < obj.value || this.value === obj.value && this.is_float && !obj.is_float ) { + return -1; + } else if( this.value > obj.value ) { + return 1; + } + }; + + // Terms + Term.prototype.compare = function( obj ) { + if( this.args.length < obj.args.length || this.args.length === obj.args.length && this.id < obj.id ) { + return -1; + } else if( this.args.length > obj.args.length || this.args.length === obj.args.length && this.id > obj.id ) { + return 1; + } else { + for( var i = 0; i < this.args.length; i++ ) { + var arg = pl.compare( this.args[i], obj.args[i] ); + if( arg !== 0 ) { + return arg; + } + } + return 0; + } + }; + + + + // SUBSTITUTIONS + + // Lookup variable + Substitution.prototype.lookup = function( variable ) { + if( this.links[variable] ) { + return this.links[variable]; + } else { + return null; + } + }; + + // Filter variables + Substitution.prototype.filter = function( predicate ) { + var links = {}; + for( var id in this.links ) { + if(!this.links.hasOwnProperty(id)) continue; + var value = this.links[id]; + if( predicate( id, value ) ) { + links[id] = value; + } + } + return new Substitution( links ); + }; + + // Exclude variables + Substitution.prototype.exclude = function( variables ) { + var links = {}; + for( var variable in this.links ) { + if(!this.links.hasOwnProperty(variable)) continue; + if( indexOf( variables, variable ) === -1 ) { + links[variable] = this.links[variable]; + } + } + return new Substitution( links ); + }; + + // Add link + Substitution.prototype.add = function( variable, value ) { + this.links[variable] = value; + }; + + // Get domain + Substitution.prototype.domain = function( plain ) { + var f = plain === true ? function(x){return x;} : function(x){return new Var(x);}; + var vars = []; + for( var x in this.links ) + vars.push( f(x) ); + return vars; + }; + + + + // GENERATE JAVASCRIPT CODE FROM PROLOG OBJECTS + + // Variables + Var.prototype.compile = function() { + return 'new pl.type.Var("' + this.id.toString() + '")'; + }; + + // Numbers + Num.prototype.compile = function() { + return 'new pl.type.Num(' + this.value.toString() + ', ' + this.is_float.toString() + ')'; + }; + + // Terms + Term.prototype.compile = function() { + return 'new pl.type.Term("' + this.id.replace(/"/g, '\\"') + '", [' + map( this.args, function( arg ) { + return arg.compile(); + } ) + '])'; + }; + + // Rules + Rule.prototype.compile = function() { + return 'new pl.type.Rule(' + this.head.compile() + ', ' + (this.body === null ? 'null' : this.body.compile()) + ')'; + }; + + // Sessions + Session.prototype.compile = function() { + var str, obj = [], rules; + for( var _indicator in this.rules ) { + if(!this.rules.hasOwnProperty(_indicator)) continue; + var indicator = this.rules[_indicator]; + rules = []; + str = "\"" + _indicator + "\": ["; + for( var i = 0; i < indicator.length; i++ ) { + rules.push( indicator[i].compile() ); + } + str += rules.join(); + str += "]"; + obj.push( str ); + } + return "{" + obj.join() + "};"; + }; + + + + // PROLOG TO JAVASCRIPT + Var.prototype.toJavaScript = function() { + return undefined; + }; + + // Numbers + Num.prototype.toJavaScript = function() { + return this.value; + }; + + // Terms + Term.prototype.toJavaScript = function() { + if( this.args.length === 0 && this.indicator !== "[]/0" ) { + return this.id; + } else if( pl.type.is_list( this ) ) { + var arr = []; + var pointer = this; + var value; + while( pointer.indicator === "./2" ) { + value = pointer.args[0].toJavaScript(); + if( value === undefined ) + return undefined; + arr.push( value ); + pointer = pointer.args[1]; + } + if( pointer.indicator === "[]/0" ) + return arr; + } + return undefined; + }; + + + + // RULES + + // Return singleton variables in the session + Rule.prototype.singleton_variables = function() { + var variables = this.head.variables(); + var count = {}; + var singleton = []; + if( this.body !== null ) + variables = variables.concat( this.body.variables() ); + for( var i = 0; i < variables.length; i++ ) { + if( count[variables[i]] === undefined ) + count[variables[i]] = 0; + count[variables[i]]++; + } + for( var key in count ) + if( key !== "_" && count[key] === 1 ) + singleton.push( key ); + return singleton; + }; + + + + // PROLOG + + var pl = { + + // Environment + __env: true && module.exports ? global : window, + + // Modules + module: {}, + + // Version + version: version, + + // Parser + parser: { + tokenizer: Tokenizer, + expression: parseExpr + }, + + // Utils + utils: { + + // String to indicator + str_indicator: str_indicator, + // Code point at + codePointAt: codePointAt, + // From code point + fromCodePoint: fromCodePoint + + }, + + // Statistics + statistics: { + + // Number of created terms + getCountTerms: function() { + return term_ref; + } + + }, + + // JavaScript to Prolog + fromJavaScript: { + + // Type testing + test: { + + // Boolean + boolean: function( obj ) { + return obj === true || obj === false; + }, + + // Number + number: function( obj ) { + return typeof obj === "number"; + }, + + // String + string: function( obj ) { + return typeof obj === "string"; + }, + + // List + list: function( obj ) { + return obj instanceof Array; + }, + + // Variable + variable: function( obj ) { + return obj === undefined; + }, + + // Any + any: function( _ ) { + return true; + } + + }, + + // Function conversion + conversion: { + + // Bolean + boolean: function( obj ) { + return new Term( obj ? "true" : "false", [] ); + }, + + // Number + number: function( obj ) { + return new Num( obj, obj % 1 !== 0 ); + }, + + // String + string: function( obj ) { + return new Term( obj, [] ); + }, + + // List + list: function( obj ) { + var arr = []; + var elem; + for( var i = 0; i < obj.length; i++ ) { + elem = pl.fromJavaScript.apply( obj[i] ); + if( elem === undefined ) + return undefined; + arr.push( elem ); + } + return arrayToList( arr ); + }, + + // Variable + variable: function( obj ) { + return new Var( "_" ); + }, + + // Any + any: function( obj ) { + return undefined; + } + + }, + + // Transform object + apply: function( obj ) { + for( var i in pl.fromJavaScript.test ) + if( i !== "any" && pl.fromJavaScript.test[i]( obj ) ) + return pl.fromJavaScript.conversion[i]( obj ); + return pl.fromJavaScript.conversion.any( obj ); + } + }, + + // Types + type: { + + // Objects + Var: Var, + Num: Num, + Term: Term, + Rule: Rule, + State: State, + Stream: Stream, + Module: Module, + Thread: Thread, + Session: Session, + Substitution: Substitution, + + // Order + order: [Var, Num, Term, Stream], + + // Compare types + compare: function( x, y ) { + var ord_x = indexOf( pl.type.order, x.constructor ); + var ord_y = indexOf( pl.type.order, y.constructor ); + if( ord_x < ord_y ) { + return -1; + } else if( ord_x > ord_y ) { + return 1; + } else { + if( x.constructor === Num ) + if( x.is_float && y.is_float ) + return 0; + else if( x.is_float ) + return -1; + else if( y.is_float ) + return 1; + return 0; + } + }, + + // Is a substitution + is_substitution: function( obj ) { + return obj instanceof Substitution; + }, + + // Is a state + is_state: function( obj ) { + return obj instanceof State; + }, + + // Is a rule + is_rule: function( obj ) { + return obj instanceof Rule; + }, + + // Is a variable + is_variable: function( obj ) { + return obj instanceof Var; + }, + + // Is a stream + is_stream: function( obj ) { + return obj instanceof Stream; + }, + + // Is an anonymous variable + is_anonymous_var: function( obj ) { + return obj instanceof Var && obj.id === "_"; + }, + + // Is a callable term + is_callable: function( obj ) { + return obj instanceof Term; + }, + + // Is a number + is_number: function( obj ) { + return obj instanceof Num; + }, + + // Is an integer + is_integer: function( obj ) { + return obj instanceof Num && !obj.is_float; + }, + + // Is a float + is_float: function( obj ) { + return obj instanceof Num && obj.is_float; + }, + + // Is a term + is_term: function( obj ) { + return obj instanceof Term; + }, + + // Is an atom + is_atom: function( obj ) { + return obj instanceof Term && obj.args.length === 0; + }, + + // Is a ground term + is_ground: function( obj ) { + if( obj instanceof Var ) return false; + if( obj instanceof Term ) + for( var i = 0; i < obj.args.length; i++ ) + if( !pl.type.is_ground( obj.args[i] ) ) + return false; + return true; + }, + + // Is atomic + is_atomic: function( obj ) { + return obj instanceof Term && obj.args.length === 0 || obj instanceof Num; + }, + + // Is compound + is_compound: function( obj ) { + return obj instanceof Term && obj.args.length > 0; + }, + + // Is a list + is_list: function( obj ) { + return obj instanceof Term && (obj.indicator === "[]/0" || obj.indicator === "./2"); + }, + + // Is an empty list + is_empty_list: function( obj ) { + return obj instanceof Term && obj.indicator === "[]/0"; + }, + + // Is a non empty list + is_non_empty_list: function( obj ) { + return obj instanceof Term && obj.indicator === "./2"; + }, + + // Is a fully list + is_fully_list: function( obj ) { + while( obj instanceof Term && obj.indicator === "./2" ) { + obj = obj.args[1]; + } + return obj instanceof Var || obj instanceof Term && obj.indicator === "[]/0"; + }, + + // Is a instantiated list + is_instantiated_list: function( obj ) { + while( obj instanceof Term && obj.indicator === "./2" ) { + obj = obj.args[1]; + } + return obj instanceof Term && obj.indicator === "[]/0"; + }, + + // Is an unitary list + is_unitary_list: function( obj ) { + return obj instanceof Term && obj.indicator === "./2" && obj.args[1] instanceof Term && obj.args[1].indicator === "[]/0"; + }, + + // Is a character + is_character: function( obj ) { + return obj instanceof Term && (obj.id.length === 1 || obj.id.length > 0 && obj.id.length <= 2 && codePointAt( obj.id, 0 ) >= 65536); + }, + + // Is a character + is_character_code: function( obj ) { + return obj instanceof Num && !obj.is_float && obj.value >= 0 && obj.value <= 1114111; + }, + + // Is a byte + is_byte: function( obj ) { + return obj instanceof Num && !obj.is_float && obj.value >= 0 && obj.value <= 255; + }, + + // Is an operator + is_operator: function( obj ) { + return obj instanceof Term && pl.arithmetic.evaluation[obj.indicator]; + }, + + // Is a directive + is_directive: function( obj ) { + return obj instanceof Term && pl.directive[obj.indicator] !== undefined; + }, + + // Is a built-in predicate + is_builtin: function( obj ) { + return obj instanceof Term && pl.predicate[obj.indicator] !== undefined; + }, + + // Is an error + is_error: function( obj ) { + return obj instanceof Term && obj.indicator === "throw/1"; + }, + + // Is a predicate indicator + is_predicate_indicator: function( obj ) { + return obj instanceof Term && obj.indicator === "//2" && obj.args[0] instanceof Term && obj.args[0].args.length === 0 && obj.args[1] instanceof Num && obj.args[1].is_float === false; + }, + + // Is a flag + is_flag: function( obj ) { + return obj instanceof Term && obj.args.length === 0 && pl.flag[obj.id] !== undefined; + }, + + // Is a valid value for a flag + is_value_flag: function( flag, obj ) { + if( !pl.type.is_flag( flag ) ) return false; + for( var value in pl.flag[flag.id].allowed ) { + if(!pl.flag[flag.id].allowed.hasOwnProperty(value)) continue; + if( pl.flag[flag.id].allowed[value].equals( obj ) ) return true; + } + return false; + }, + + // Is a io mode + is_io_mode: function( obj ) { + return pl.type.is_atom( obj ) && ["read","write","append"].indexOf( obj.id ) !== -1; + }, + + // Is a stream option + is_stream_option: function( obj ) { + return pl.type.is_term( obj ) && ( + obj.indicator === "alias/1" && pl.type.is_atom(obj.args[0]) || + obj.indicator === "reposition/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || + obj.indicator === "type/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "text" || obj.args[0].id === "binary") || + obj.indicator === "eof_action/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "error" || obj.args[0].id === "eof_code" || obj.args[0].id === "reset") + ); + }, + + // Is a stream position + is_stream_position: function( obj ) { + return pl.type.is_integer( obj ) && obj.value >= 0 || pl.type.is_atom( obj ) && (obj.id === "end_of_stream" || obj.id === "past_end_of_stream"); + }, + + // Is a stream property + is_stream_property: function( obj ) { + return pl.type.is_term( obj ) && ( + obj.indicator === "input/0" || + obj.indicator === "output/0" || + obj.indicator === "alias/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom( obj.args[0] )) || + obj.indicator === "file_name/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom( obj.args[0] )) || + obj.indicator === "position/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_stream_position( obj.args[0] )) || + obj.indicator === "reposition/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false")) || + obj.indicator === "type/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "text" || obj.args[0].id === "binary")) || + obj.indicator === "mode/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "read" || obj.args[0].id === "write" || obj.args[0].id === "append")) || + obj.indicator === "eof_action/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "error" || obj.args[0].id === "eof_code" || obj.args[0].id === "reset")) || + obj.indicator === "end_of_stream/1" && (pl.type.is_variable( obj.args[0] ) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "at" || obj.args[0].id === "past" || obj.args[0].id === "not")) + ); + }, + + // Is a streamable term + is_streamable: function( obj ) { + return obj.__proto__.stream !== undefined; + }, + + // Is a read option + is_read_option: function( obj ) { + return pl.type.is_term( obj ) && ["variables/1","variable_names/1","singletons/1"].indexOf( obj.indicator ) !== -1; + }, + + // Is a write option + is_write_option: function( obj ) { + return pl.type.is_term( obj ) && ( + obj.indicator === "quoted/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || + obj.indicator === "ignore_ops/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || + obj.indicator === "numbervars/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") + ); + }, + + // Is a close option + is_close_option: function( obj ) { + return pl.type.is_term( obj ) && + obj.indicator === "force/1" && + pl.type.is_atom(obj.args[0]) && + (obj.args[0].id === "true" || obj.args[0].id === "false"); + }, + + // Is a modifiable flag + is_modifiable_flag: function( obj ) { + return pl.type.is_flag( obj ) && pl.flag[obj.id].changeable; + }, + + // Is an existing module + is_module: function( obj ) { + return obj instanceof Term && obj.indicator === "library/1" && obj.args[0] instanceof Term && obj.args[0].args.length === 0 && pl.module[obj.args[0].id] !== undefined; + } + + }, + + // Arithmetic functions + arithmetic: { + + // Evaluation + evaluation: { + "e/0": { + type_args: null, + type_result: true, + fn: function( _ ) { return Math.E; } + }, + "pi/0": { + type_args: null, + type_result: true, + fn: function( _ ) { return Math.PI; } + }, + "tau/0": { + type_args: null, + type_result: true, + fn: function( _ ) { return 2*Math.PI; } + }, + "epsilon/0": { + type_args: null, + type_result: true, + fn: function( _ ) { return Number.EPSILON; } + }, + "+/1": { + type_args: null, + type_result: null, + fn: function( x, _ ) { return x; } + }, + "-/1": { + type_args: null, + type_result: null, + fn: function( x, _ ) { return -x; } + }, + "\\/1": { + type_args: false, + type_result: false, + fn: function( x, _ ) { return ~x; } + }, + "abs/1": { + type_args: null, + type_result: null, + fn: function( x, _ ) { return Math.abs( x ); } + }, + "sign/1": { + type_args: null, + type_result: null, + fn: function( x, _ ) { return Math.sign( x ); } + }, + "float_integer_part/1": { + type_args: true, + type_result: false, + fn: function( x, _ ) { return parseInt( x ); } + }, + "float_fractional_part/1": { + type_args: true, + type_result: true, + fn: function( x, _ ) { return x - parseInt( x ); } + }, + "float/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return parseFloat( x ); } + }, + "floor/1": { + type_args: true, + type_result: false, + fn: function( x, _ ) { return Math.floor( x ); } + }, + "truncate/1": { + type_args: true, + type_result: false, + fn: function( x, _ ) { return parseInt( x ); } + }, + "round/1": { + type_args: true, + type_result: false, + fn: function( x, _ ) { return Math.round( x ); } + }, + "ceiling/1": { + type_args: true, + type_result: false, + fn: function( x, _ ) { return Math.ceil( x ); } + }, + "sin/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.sin( x ); } + }, + "cos/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.cos( x ); } + }, + "tan/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.tan( x ); } + }, + "asin/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.asin( x ); } + }, + "acos/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.acos( x ); } + }, + "atan/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.atan( x ); } + }, + "atan2/2": { + type_args: null, + type_result: true, + fn: function( x, y, _ ) { return Math.atan2( x, y ); } + }, + "exp/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.exp( x ); } + }, + "sqrt/1": { + type_args: null, + type_result: true, + fn: function( x, _ ) { return Math.sqrt( x ); } + }, + "log/1": { + type_args: null, + type_result: true, + fn: function( x, thread ) { return x > 0 ? Math.log( x ) : pl.error.evaluation( "undefined", thread.__call_indicator ); } + }, + "+/2": { + type_args: null, + type_result: null, + fn: function( x, y, _ ) { return x + y; } + }, + "-/2": { + type_args: null, + type_result: null, + fn: function( x, y, _ ) { return x - y; } + }, + "*/2": { + type_args: null, + type_result: null, + fn: function( x, y, _ ) { return x * y; } + }, + "//2": { + type_args: null, + type_result: true, + fn: function( x, y, thread ) { return y ? x / y : pl.error.evaluation( "zero_division", thread.__call_indicator ); } + }, + "///2": { + type_args: false, + type_result: false, + fn: function( x, y, thread ) { return y ? parseInt( x / y ) : pl.error.evaluation( "zero_division", thread.__call_indicator ); } + }, + "**/2": { + type_args: null, + type_result: true, + fn: function( x, y, _ ) { return Math.pow(x, y); } + }, + "^/2": { + type_args: null, + type_result: null, + fn: function( x, y, _ ) { return Math.pow(x, y); } + }, + "<>/2": { + type_args: false, + type_result: false, + fn: function( x, y, _ ) { return x >> y; } + }, + "/\\/2": { + type_args: false, + type_result: false, + fn: function( x, y, _ ) { return x & y; } + }, + "\\//2": { + type_args: false, + type_result: false, + fn: function( x, y, _ ) { return x | y; } + }, + "xor/2": { + type_args: false, + type_result: false, + fn: function( x, y, _ ) { return x ^ y; } + }, + "rem/2": { + type_args: false, + type_result: false, + fn: function( x, y, thread ) { return y ? x % y : pl.error.evaluation( "zero_division", thread.__call_indicator ); } + }, + "mod/2": { + type_args: false, + type_result: false, + fn: function( x, y, thread ) { return y ? x - parseInt( x / y ) * y : pl.error.evaluation( "zero_division", thread.__call_indicator ); } + }, + "max/2": { + type_args: null, + type_result: null, + fn: function( x, y, _ ) { return Math.max( x, y ); } + }, + "min/2": { + type_args: null, + type_result: null, + fn: function( x, y, _ ) { return Math.min( x, y ); } + } + + } + + }, + + // Directives + directive: { + + // dynamic/1 + "dynamic/1": function( thread, atom ) { + var indicator = atom.args[0]; + if( pl.type.is_variable( indicator ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_compound( indicator ) || indicator.indicator !== "//2" ) { + thread.throw_error( pl.error.type( "predicate_indicator", indicator, atom.indicator ) ); + } else if( pl.type.is_variable( indicator.args[0] ) || pl.type.is_variable( indicator.args[1] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( indicator.args[0] ) ) { + thread.throw_error( pl.error.type( "atom", indicator.args[0], atom.indicator ) ); + } else if( !pl.type.is_integer( indicator.args[1] ) ) { + thread.throw_error( pl.error.type( "integer", indicator.args[1], atom.indicator ) ); + } else { + var key = atom.args[0].args[0].id + "/" + atom.args[0].args[1].value; + thread.session.public_predicates[key] = true; + if( !thread.session.rules[key] ) + thread.session.rules[key] = []; + } + }, + + // multifile/1 + "multifile/1": function( thread, atom ) { + var indicator = atom.args[0]; + if( pl.type.is_variable( indicator ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_compound( indicator ) || indicator.indicator !== "//2" ) { + thread.throw_error( pl.error.type( "predicate_indicator", indicator, atom.indicator ) ); + } else if( pl.type.is_variable( indicator.args[0] ) || pl.type.is_variable( indicator.args[1] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( indicator.args[0] ) ) { + thread.throw_error( pl.error.type( "atom", indicator.args[0], atom.indicator ) ); + } else if( !pl.type.is_integer( indicator.args[1] ) ) { + thread.throw_error( pl.error.type( "integer", indicator.args[1], atom.indicator ) ); + } else { + thread.session.multifile_predicates[atom.args[0].args[0].id + "/" + atom.args[0].args[1].value] = true; + } + }, + + // set_prolog_flag + "set_prolog_flag/2": function( thread, atom ) { + var flag = atom.args[0], value = atom.args[1]; + if( pl.type.is_variable( flag ) || pl.type.is_variable( value ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( flag ) ) { + thread.throw_error( pl.error.type( "atom", flag, atom.indicator ) ); + } else if( !pl.type.is_flag( flag ) ) { + thread.throw_error( pl.error.domain( "prolog_flag", flag, atom.indicator ) ); + } else if( !pl.type.is_value_flag( flag, value ) ) { + thread.throw_error( pl.error.domain( "flag_value", new Term( "+", [flag, value] ), atom.indicator ) ); + } else if( !pl.type.is_modifiable_flag( flag ) ) { + thread.throw_error( pl.error.permission( "modify", "flag", flag ) ); + } else { + thread.session.flag[flag.id] = value; + } + }, + + // use_module/1 + "use_module/1": function( thread, atom ) { + var module = atom.args[0]; + if( pl.type.is_variable( module ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_term( module ) ) { + thread.throw_error( pl.error.type( "term", module, atom.indicator ) ); + } else { + if( pl.type.is_module( module ) ) { + var name = module.args[0].id; + if( indexOf(thread.session.modules, name) === -1 ) + thread.session.modules.push( name ); + } else { + // TODO + // error no existe modulo + } + } + }, + + // char_conversion/2 + "char_conversion/2": function( thread, atom ) { + var inchar = atom.args[0], outchar = atom.args[1]; + if( pl.type.is_variable( inchar ) || pl.type.is_variable( outchar ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_character( inchar ) ) { + thread.throw_error( pl.error.type( "character", inchar, atom.indicator ) ); + } else if( !pl.type.is_character( outchar ) ) { + thread.throw_error( pl.error.type( "character", outchar, atom.indicator ) ); + } else { + if( inchar.id === outchar.id ) { + delete thread.session.__char_conversion[inchar.id]; + } else { + thread.session.__char_conversion[inchar.id] = outchar.id; + } + } + }, + + // op/3 + "op/3": function( thread, atom ) { + var priority = atom.args[0], type = atom.args[1], operator = atom.args[2]; + if( pl.type.is_variable( priority ) || pl.type.is_variable( type ) || pl.type.is_variable( operator ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_integer( priority ) ) { + thread.throw_error( pl.error.type( "integer", priority, atom.indicator ) ); + } else if( !pl.type.is_atom( type ) ) { + thread.throw_error( pl.error.type( "atom", type, atom.indicator ) ); + } else if( !pl.type.is_atom( operator ) ) { + thread.throw_error( pl.error.type( "atom", operator, atom.indicator ) ); + } else if( priority.value < 0 || priority.value > 1200 ) { + thread.throw_error( pl.error.domain( "operator_priority", priority, atom.indicator ) ); + } else if( operator.id === "," ) { + thread.throw_error( pl.error.permission( "modify", "operator", operator, atom.indicator ) ); + } else if( operator.id === "|" && (priority.value < 1001 || type.id.length !== 3 ) ) { + thread.throw_error( pl.error.permission( "modify", "operator", operator, atom.indicator ) ); + } else if( ["fy", "fx", "yf", "xf", "xfx", "yfx", "xfy"].indexOf( type.id ) === -1 ) { + thread.throw_error( pl.error.domain( "operator_specifier", type, atom.indicator ) ); + } else { + var fix = { prefix: null, infix: null, postfix: null }; + for( var p in thread.session.__operators ) { + if(!thread.session.__operators.hasOwnProperty(p)) continue; + var classes = thread.session.__operators[p][operator.id]; + if( classes ) { + if( indexOf( classes, "fx" ) !== -1 ) { fix.prefix = { priority: p, type: "fx" }; } + if( indexOf( classes, "fy" ) !== -1 ) { fix.prefix = { priority: p, type: "fy" }; } + if( indexOf( classes, "xf" ) !== -1 ) { fix.postfix = { priority: p, type: "xf" }; } + if( indexOf( classes, "yf" ) !== -1 ) { fix.postfix = { priority: p, type: "yf" }; } + if( indexOf( classes, "xfx" ) !== -1 ) { fix.infix = { priority: p, type: "xfx" }; } + if( indexOf( classes, "xfy" ) !== -1 ) { fix.infix = { priority: p, type: "xfy" }; } + if( indexOf( classes, "yfx" ) !== -1 ) { fix.infix = { priority: p, type: "yfx" }; } + } + } + var current_class; + switch( type.id ) { + case "fy": case "fx": current_class = "prefix"; break; + case "yf": case "xf": current_class = "postfix"; break; + default: current_class = "infix"; break; + } + if( ((fix.prefix && current_class === "prefix" || fix.postfix && current_class === "postfix" || fix.infix && current_class === "infix") + && fix[current_class].type !== type.id || fix.infix && current_class === "postfix" || fix.postfix && current_class === "infix") && priority.value !== 0 ) { + thread.throw_error( pl.error.permission( "create", "operator", operator, atom.indicator ) ); + } else { + if( fix[current_class] ) { + remove( thread.session.__operators[fix[current_class].priority][operator.id], type.id ); + if( thread.session.__operators[fix[current_class].priority][operator.id].length === 0 ) { + delete thread.session.__operators[fix[current_class].priority][operator.id]; + } + } + if( priority.value > 0 ) { + if( !thread.session.__operators[priority.value] ) thread.session.__operators[priority.value.toString()] = {}; + if( !thread.session.__operators[priority.value][operator.id] ) thread.session.__operators[priority.value][operator.id] = []; + thread.session.__operators[priority.value][operator.id].push( type.id ); + } + return true; + } + } + } + + }, + + // Built-in predicates + predicate: { + + // INPUT AND OUTPUT + + // op/3 + "op/3": function( thread, point, atom ) { + if( pl.directive["op/3"]( thread, atom ) ) + thread.success( point ); + }, + + // current_op/3 + "current_op/3": function( thread, point, atom ) { + var priority = atom.args[0], specifier = atom.args[1], operator = atom.args[2]; + var points = []; + for( var p in thread.session.__operators ) + for( var o in thread.session.__operators[p] ) + for( var i = 0; i < thread.session.__operators[p][o].length; i++ ) + points.push( new State( + point.goal.replace( + new Term( ",", [ + new Term( "=", [new Num( p, false ), priority] ), + new Term( ",", [ + new Term( "=", [new Term( thread.session.__operators[p][o][i], [] ), specifier] ), + new Term( "=", [new Term( o, [] ), operator] ) + ] ) + ] ) + ), + point.substitution, + point + ) ); + thread.prepend( points ); + }, + + // LOGIC AND CONTROL STRUCTURES + + // ;/2 (disjunction) + ";/2": function( thread, point, atom ) { + if( pl.type.is_term( atom.args[0] ) && atom.args[0].indicator === "->/2" ) { + var points = thread.points; + var format_success = thread.session.format_success; + var format_error = thread.session.format_error; + thread.session.format_success = function(x) { return x.substitution; }; + thread.session.format_error = function(x) { return x.goal; }; + thread.points = [new State( atom.args[0].args[0], point.substitution, point )]; + var callback = function( answer ) { + thread.points = points; + thread.session.format_success = format_success; + thread.session.format_error = format_error; + if( answer === false ) { + thread.prepend( [new State( point.goal.replace( atom.args[1] ), point.substitution, point )] ); + } else if( pl.type.is_error( answer ) ) + thread.throw_error( answer.args[0] ); + else if( answer === null ) { + thread.prepend( [point] ); + thread.__calls.shift()( null ); + } else { + thread.prepend( [new State( point.goal.replace( atom.args[0].args[1] ).apply( answer ), point.substitution.apply( answer ), point )] ); + } + }; + thread.__calls.unshift( callback ); + } else { + var left = new State( point.goal.replace( atom.args[0] ), point.substitution, point ); + var right = new State( point.goal.replace( atom.args[1] ), point.substitution, point ); + thread.prepend( [left, right] ); + } + }, + + // !/0 (cut) + "!/0": function( thread, point, atom ) { + var parent_cut, last_cut, states = []; + parent_cut = point; + last_cut = null; + while( parent_cut.parent !== null && parent_cut.parent.goal.search( atom ) ) { + last_cut = parent_cut; + parent_cut = parent_cut.parent; + if(parent_cut.goal !== null) { + var selected = parent_cut.goal.select(); + if( selected && selected.id === "call" && selected.search(atom) ) { + parent_cut = last_cut; + break; + } + } + } + for( var i = thread.points.length-1; i >= 0; i-- ) { + var state = thread.points[i]; + var node = state.parent; + while( node !== null && node !== parent_cut.parent ) { + node = node.parent; + } + if( node === null && node !== parent_cut.parent ) + states.push( state ); + } + thread.points = states.reverse(); + thread.success( point ); + }, + + // \+ (negation) + "\\+/1": function( thread, point, atom ) { + var goal = atom.args[0]; + if( pl.type.is_variable( goal ) ) { + thread.throw_error( pl.error.instantiation( thread.level ) ); + } else if( !pl.type.is_callable( goal ) ) { + thread.throw_error( pl.error.type( "callable", goal, thread.level ) ); + } else { + // TRANSPARENT VERSION OF THE NEGATION + /*var neg_thread; + if(point.negation_thread) { + neg_thread = point.negation_thread; + } else { + neg_thread = new Thread( thread.session ); + neg_thread.add_goal( goal ); + point.negation_thread = neg_thread; + } + neg_thread.answer( function( answer ) { + if(answer === false) { + thread.success( point ); + } else if(pl.type.is_error( answer )) { + thread.throw_error( answer.args[0] ); + } else if(answer === null) { + thread.prepend( [point] ); + thread.current_limit = 0; + } + thread.again( answer !== null ); + } ); + return true;*/ + + // '\+'(X) :- call(X), !, fail. + // '\+'(_). + thread.prepend( [ + new State( point.goal.replace( new Term( ",", [new Term( ",", [ new Term( "call", [goal] ), new Term( "!", [] ) ] ), new Term( "fail", [] ) ] ) ), point.substitution, point ), + new State( point.goal.replace( null ), point.substitution, point ) + ] ); + } + }, + + // ->/2 (implication) + "->/2": function( thread, point, atom ) { + var goal = point.goal.replace( new Term( ",", [atom.args[0], new Term( ",", [new Term( "!" ), atom.args[1]] )] ) ); + thread.prepend( [new State( goal, point.substitution, point )] ); + }, + + // fail/0 + "fail/0": function( _1, _2, _3 ) {}, + + // false/0 + "false/0": function( _1, _2, _3 ) {}, + + // true/0 + "true/0": function( thread, point, _ ) { + thread.success( point ); + }, + + // call/1..8 + "call/1": callN(1), + "call/2": callN(2), + "call/3": callN(3), + "call/4": callN(4), + "call/5": callN(5), + "call/6": callN(6), + "call/7": callN(7), + "call/8": callN(8), + + // once/1 + "once/1": function( thread, point, atom ) { + var goal = atom.args[0]; + thread.prepend( [new State( point.goal.replace( new Term( ",", [new Term( "call", [goal] ), new Term( "!", [] )] ) ), point.substitution, point )] ); + }, + + // forall/2 + "forall/2": function( thread, point, atom ) { + var generate = atom.args[0], test = atom.args[1]; + thread.prepend( [new State( point.goal.replace( new Term( "\\+", [new Term( ",", [new Term( "call", [generate] ), new Term( "\\+", [new Term( "call", [test] )] )] )] ) ), point.substitution, point )] ); + }, + + // repeat/0 + "repeat/0": function( thread, point, _ ) { + thread.prepend( [new State( point.goal.replace( null ), point.substitution, point ), point] ); + }, + + // EXCEPTIONS + + // throw/1 + "throw/1": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.throw_error( pl.error.instantiation( thread.level ) ); + } else { + thread.throw_error( atom.args[0] ); + } + }, + + // catch/3 + "catch/3": function( thread, point, atom ) { + var points = thread.points; + thread.points = []; + thread.prepend( [new State( atom.args[0], point.substitution, point )] ); + var format_success = thread.session.format_success; + var format_error = thread.session.format_error; + thread.session.format_success = function(x) { return x.substitution; }; + thread.session.format_error = function(x) { return x.goal; }; + var callback = function( answer ) { + var call_points = thread.points; + thread.points = points; + thread.session.format_success = format_success; + thread.session.format_error = format_error; + if( pl.type.is_error( answer ) ) { + var states = []; + for( var i = thread.points.length-1 ; i >= 0; i-- ) { + var state = thread.points[i]; + var node = state.parent; + while( node !== null && node !== point.parent ) { + node = node.parent; + } + if( node === null && node !== point.parent ) + states.push( state ); + } + thread.points = states; + var occurs_check = thread.get_flag( "occurs_check" ).indicator === "true/0"; + var state = new State(); + var mgu = pl.unify( answer.args[0], atom.args[1], occurs_check ); + if( mgu !== null ) { + state.substitution = point.substitution.apply( mgu ); + state.goal = point.goal.replace( atom.args[2] ).apply( mgu ); + state.parent = point; + thread.prepend( [state] ); + } else { + thread.throw_error( answer.args[0] ); + } + } else if( answer !== false ) { + var answer_state = answer === null ? [] : [new State( + point.goal.apply( answer ).replace( null ), + point.substitution.apply( answer ), + point + )]; + var filter_points = []; + for( var i = call_points.length-1; i >= 0; i-- ) { + filter_points.push( call_points[i] ); + var selected = call_points[i].goal !== null ? call_points[i].goal.select() : null; + if( pl.type.is_term( selected ) && selected.indicator === "!/0" ) + break; + } + var catch_points = map( filter_points, function( state ) { + if( state.goal === null ) + state.goal = new Term( "true", [] ); + state = new State( + point.goal.replace( new Term( "catch", [state.goal, atom.args[1], atom.args[2]] ) ), + point.substitution.apply( state.substitution ), + state.parent + ); + state.exclude = atom.args[0].variables(); + return state; + } ).reverse(); + thread.prepend( catch_points ); + thread.prepend( answer_state ); + if( answer === null ) { + this.current_limit = 0; + thread.__calls.shift()( null ); + } + } + }; + thread.__calls.unshift( callback ); + }, + + // UNIFICATION + + // =/2 (unification) + "=/2": function( thread, point, atom ) { + var occurs_check = thread.get_flag( "occurs_check" ).indicator === "true/0"; + var state = new State(); + var mgu = pl.unify( atom.args[0], atom.args[1], occurs_check ); + if( mgu !== null ) { + state.goal = point.goal.apply( mgu ).replace( null ); + state.substitution = point.substitution.apply( mgu ); + state.parent = point; + thread.prepend( [state] ); + } + }, + + // unify_with_occurs_check/2 + "unify_with_occurs_check/2": function( thread, point, atom ) { + var state = new State(); + var mgu = pl.unify( atom.args[0], atom.args[1], true ); + if( mgu !== null ) { + state.goal = point.goal.apply( mgu ).replace( null ); + state.substitution = point.substitution.apply( mgu ); + state.parent = point; + thread.prepend( [state] ); + } + }, + + // \=/2 + "\\=/2": function( thread, point, atom ) { + var occurs_check = thread.get_flag( "occurs_check" ).indicator === "true/0"; + var mgu = pl.unify( atom.args[0], atom.args[1], occurs_check ); + if( mgu === null ) { + thread.success( point ); + } + }, + + // subsumes_term/2 + "subsumes_term/2": function( thread, point, atom ) { + var occurs_check = thread.get_flag( "occurs_check" ).indicator === "true/0"; + var mgu = pl.unify( atom.args[1], atom.args[0], occurs_check ); + if( mgu !== null && atom.args[1].apply( mgu ).equals( atom.args[1] ) ) { + thread.success( point ); + } + }, + + // ALL SOLUTIONS + + // findall/3 + "findall/3": function( thread, point, atom ) { + var template = atom.args[0], goal = atom.args[1], instances = atom.args[2]; + if( pl.type.is_variable( goal ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( goal ) ) { + thread.throw_error( pl.error.type( "callable", goal, atom.indicator ) ); + } else if( !pl.type.is_variable( instances ) && !pl.type.is_list( instances ) ) { + thread.throw_error( pl.error.type( "list", instances, atom.indicator ) ); + } else { + var variable = thread.next_free_variable(); + var newGoal = new Term( ",", [goal, new Term( "=", [variable, template] )] ); + var points = thread.points; + var limit = thread.session.limit; + var format_success = thread.session.format_success; + thread.session.format_success = function(x) { return x.substitution; }; + thread.add_goal( newGoal, true, point ); + var answers = []; + var callback = function( answer ) { + if( answer !== false && answer !== null && !pl.type.is_error( answer ) ) { + thread.__calls.unshift( callback ); + answers.push( answer.links[variable.id] ); + thread.session.limit = thread.current_limit; + } else { + thread.points = points; + thread.session.limit = limit; + thread.session.format_success = format_success; + if( pl.type.is_error( answer ) ) { + thread.throw_error( answer.args[0] ); + } else if( thread.current_limit > 0 ) { + var list = new Term( "[]" ); + for( var i = answers.length - 1; i >= 0; i-- ) { + list = new Term( ".", [answers[i], list] ); + } + thread.prepend( [new State( point.goal.replace( new Term( "=", [instances, list] ) ), point.substitution, point )] ); + } + } + }; + thread.__calls.unshift( callback ); + } + }, + + // bagof/3 + "bagof/3": function( thread, point, atom ) { + var answer, template = atom.args[0], goal = atom.args[1], instances = atom.args[2]; + if( pl.type.is_variable( goal ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( goal ) ) { + thread.throw_error( pl.error.type( "callable", goal, atom.indicator ) ); + } else if( !pl.type.is_variable( instances ) && !pl.type.is_list( instances ) ) { + thread.throw_error( pl.error.type( "list", instances, atom.indicator ) ); + } else { + var variable = thread.next_free_variable(); + var template_vars; + if( goal.indicator === "^/2" ) { + template_vars = goal.args[0].variables(); + goal = goal.args[1]; + } else { + template_vars = []; + } + template_vars = template_vars.concat( template.variables() ); + var free_vars = goal.variables().filter( function( v ){ + return indexOf( template_vars, v ) === -1; + } ); + var list_vars = new Term( "[]" ); + for( var i = free_vars.length - 1; i >= 0; i-- ) { + list_vars = new Term( ".", [ new Var( free_vars[i] ), list_vars ] ); + } + var newGoal = new Term( ",", [goal, new Term( "=", [variable, new Term( ",", [list_vars, template] )] )] ); + var points = thread.points; + var limit = thread.session.limit; + var format_success = thread.session.format_success; + thread.session.format_success = function(x) { return x.substitution; }; + thread.add_goal( newGoal, true, point ); + var answers = []; + var callback = function( answer ) { + if( answer !== false && answer !== null && !pl.type.is_error( answer ) ) { + thread.__calls.unshift( callback ); + var match = false; + var arg_vars = answer.links[variable.id].args[0]; + var arg_template = answer.links[variable.id].args[1]; + for( var _elem in answers ) { + if(!answers.hasOwnProperty(_elem)) continue; + var elem = answers[_elem]; + if( elem.variables.equals( arg_vars ) ) { + elem.answers.push( arg_template ); + match = true; + break; + } + } + if( !match ) { + answers.push( {variables: arg_vars, answers: [arg_template]} ); + } + thread.session.limit = thread.current_limit; + } else { + thread.points = points; + thread.session.limit = limit; + thread.session.format_success = format_success; + if( pl.type.is_error( answer ) ) { + thread.throw_error( answer.args[0] ); + } else if( thread.current_limit > 0 ) { + var states = []; + for( var i = 0; i < answers.length; i++ ) { + answer = answers[i].answers; + var list = new Term( "[]" ); + for( var j = answer.length - 1; j >= 0; j-- ) { + list = new Term( ".", [answer[j], list] ); + } + states.push( new State( + point.goal.replace( new Term( ",", [new Term( "=", [list_vars, answers[i].variables] ), new Term( "=", [instances, list] )] ) ), + point.substitution, point + ) ); + } + thread.prepend( states ); + } + } + }; + thread.__calls.unshift( callback ); + } + }, + + // setof/3 + "setof/3": function( thread, point, atom ) { + var answer, template = atom.args[0], goal = atom.args[1], instances = atom.args[2]; + if( pl.type.is_variable( goal ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( goal ) ) { + thread.throw_error( pl.error.type( "callable", goal, atom.indicator ) ); + } else if( !pl.type.is_variable( instances ) && !pl.type.is_list( instances ) ) { + thread.throw_error( pl.error.type( "list", instances, atom.indicator ) ); + } else { + var variable = thread.next_free_variable(); + var template_vars; + if( goal.indicator === "^/2" ) { + template_vars = goal.args[0].variables(); + goal = goal.args[1]; + } else { + template_vars = []; + } + template_vars = template_vars.concat( template.variables() ); + var free_vars = goal.variables().filter( function( v ){ + return indexOf( template_vars, v ) === -1; + } ); + var list_vars = new Term( "[]" ); + for( var i = free_vars.length - 1; i >= 0; i-- ) { + list_vars = new Term( ".", [ new Var( free_vars[i] ), list_vars ] ); + } + var newGoal = new Term( ",", [goal, new Term( "=", [variable, new Term( ",", [list_vars, template] )] )] ); + var points = thread.points; + var limit = thread.session.limit; + var format_success = thread.session.format_success; + thread.session.format_success = function(x) { return x.substitution; }; + thread.add_goal( newGoal, true, point ); + var answers = []; + var callback = function( answer ) { + if( answer !== false && answer !== null && !pl.type.is_error( answer ) ) { + thread.__calls.unshift( callback ); + var match = false; + var arg_vars = answer.links[variable.id].args[0]; + var arg_template = answer.links[variable.id].args[1]; + for( var _elem in answers ) { + if(!answers.hasOwnProperty(_elem)) continue; + var elem = answers[_elem]; + if( elem.variables.equals( arg_vars ) ) { + elem.answers.push( arg_template ); + match = true; + break; + } + } + if( !match ) { + answers.push( {variables: arg_vars, answers: [arg_template]} ); + } + thread.session.limit = thread.current_limit; + } else { + thread.points = points; + thread.session.limit = limit; + thread.session.format_success = format_success; + if( pl.type.is_error( answer ) ) { + thread.throw_error( answer.args[0] ); + } else if( thread.current_limit > 0 ) { + var states = []; + for( var i = 0; i < answers.length; i++ ) { + answer = answers[i].answers.sort( pl.compare ); + var list = new Term( "[]" ); + for( var j = answer.length - 1; j >= 0; j-- ) { + list = new Term( ".", [answer[j], list] ); + } + states.push( new State( + point.goal.replace( new Term( ",", [new Term( "=", [list_vars, answers[i].variables] ), new Term( "=", [instances, list] )] ) ), + point.substitution, point + ) ); + } + thread.prepend( states ); + } + } + }; + thread.__calls.unshift( callback ); + } + }, + + // TERM CREATION AND DECOMPOSITION + + // functor/3 + "functor/3": function( thread, point, atom ) { + var subs; + var term = atom.args[0], name = atom.args[1], arity = atom.args[2]; + if( pl.type.is_variable( term ) && (pl.type.is_variable( name ) || pl.type.is_variable( arity )) ) { + thread.throw_error( pl.error.instantiation( "functor/3" ) ); + } else if( !pl.type.is_variable( arity ) && !pl.type.is_integer( arity ) ) { + thread.throw_error( pl.error.type( "integer", atom.args[2], "functor/3" ) ); + } else if( !pl.type.is_variable( name ) && !pl.type.is_atomic( name ) ) { + thread.throw_error( pl.error.type( "atomic", atom.args[1], "functor/3" ) ); + } else if( pl.type.is_integer( name ) && pl.type.is_integer( arity ) && arity.value !== 0 ) { + thread.throw_error( pl.error.type( "atom", atom.args[1], "functor/3" ) ); + } else if( pl.type.is_variable( term ) ) { + if( atom.args[2].value >= 0 ) { + var args = []; + for( var i = 0; i < arity.value; i++ ) + args.push( thread.next_free_variable() ); + var functor = pl.type.is_integer( name ) ? name : new Term( name.id, args ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [term, functor] ) ), point.substitution, point )] ); + } + } else { + var id = pl.type.is_integer( term ) ? term : new Term( term.id, [] ); + var length = pl.type.is_integer( term ) ? new Num( 0, false ) : new Num( term.args.length, false ); + var goal = new Term( ",", [new Term( "=", [id, name] ), new Term( "=", [length, arity] )] ); + thread.prepend( [new State( point.goal.replace( goal ), point.substitution, point )] ); + } + }, + + // arg/3 + "arg/3": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) || pl.type.is_variable( atom.args[1] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( atom.args[0].value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", atom.args[0], atom.indicator ) ); + } else if( !pl.type.is_compound( atom.args[1] ) ) { + thread.throw_error( pl.error.type( "compound", atom.args[1], atom.indicator ) ); + } else { + var n = atom.args[0].value; + if( n > 0 && n <= atom.args[1].args.length ) { + var goal = new Term( "=", [atom.args[1].args[n-1], atom.args[2]] ); + thread.prepend( [new State( point.goal.replace( goal ), point.substitution, point )] ); + } + } + }, + + // =../2 (univ) + "=../2": function( thread, point, atom ) { + var list; + if( pl.type.is_variable( atom.args[0] ) && (pl.type.is_variable( atom.args[1] ) + || pl.type.is_non_empty_list( atom.args[1] ) && pl.type.is_variable( atom.args[1].args[0] )) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_fully_list( atom.args[1] ) ) { + thread.throw_error( pl.error.type( "list", atom.args[1], atom.indicator ) ); + } else if( !pl.type.is_variable( atom.args[0] ) ) { + if( pl.type.is_atomic( atom.args[0] ) ) { + list = new Term( ".", [atom.args[0], new Term( "[]" )] ); + } else { + list = new Term( "[]" ); + for( var i = atom.args[0].args.length - 1; i >= 0; i-- ) { + list = new Term( ".", [atom.args[0].args[i], list] ); + } + list = new Term( ".", [new Term( atom.args[0].id ), list] ); + } + thread.prepend( [new State( point.goal.replace( new Term( "=", [list, atom.args[1]] ) ), point.substitution, point )] ); + } else if( !pl.type.is_variable( atom.args[1] ) ) { + var args = []; + list = atom.args[1].args[1]; + while( list.indicator === "./2" ) { + args.push( list.args[0] ); + list = list.args[1]; + } + if( pl.type.is_variable( atom.args[0] ) && pl.type.is_variable( list ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( args.length === 0 && pl.type.is_compound( atom.args[1].args[0] ) ) { + thread.throw_error( pl.error.type( "atomic", atom.args[1].args[0], atom.indicator ) ); + } else if( args.length > 0 && (pl.type.is_compound( atom.args[1].args[0] ) || pl.type.is_number( atom.args[1].args[0] )) ) { + thread.throw_error( pl.error.type( "atom", atom.args[1].args[0], atom.indicator ) ); + } else { + if( args.length === 0 ) { + thread.prepend( [new State( point.goal.replace( new Term( "=", [atom.args[1].args[0], atom.args[0]], point ) ), point.substitution, point )] ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [new Term( atom.args[1].args[0].id, args ), atom.args[0]] ) ), point.substitution, point )] ); + } + } + } + }, + + // copy_term/2 + "copy_term/2": function( thread, point, atom ) { + var renamed = atom.args[0].rename( thread ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [renamed, atom.args[1]] ) ), point.substitution, point.parent )] ); + }, + + // term_variables/2 + "term_variables/2": function( thread, point, atom ) { + var term = atom.args[0], vars = atom.args[1]; + if( !pl.type.is_fully_list( vars ) ) { + thread.throw_error( pl.error.type( "list", vars, atom.indicator ) ); + } else { + var list = arrayToList( map( nub( term.variables() ), function(v) { + return new Var(v); + } ) ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [vars, list] ) ), point.substitution, point )] ); + } + }, + + // CLAUSE RETRIEVAL AND INFORMATION + + // clause/2 + "clause/2": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( atom.args[0] ) ) { + thread.throw_error( pl.error.type( "callable", atom.args[0], atom.indicator ) ); + } else if( !pl.type.is_variable( atom.args[1] ) && !pl.type.is_callable( atom.args[1] ) ) { + thread.throw_error( pl.error.type( "callable", atom.args[1], atom.indicator ) ); + } else if( thread.session.rules[atom.args[0].indicator] !== undefined ) { + if( thread.is_public_predicate( atom.args[0].indicator ) ) { + var states = []; + for( var _rule in thread.session.rules[atom.args[0].indicator] ) { + if(!thread.session.rules[atom.args[0].indicator].hasOwnProperty(_rule)) continue; + var rule = thread.session.rules[atom.args[0].indicator][_rule]; + thread.session.renamed_variables = {}; + rule = rule.rename( thread ); + if( rule.body === null ) { + rule.body = new Term( "true" ); + } + var goal = new Term( ",", [new Term( "=", [rule.head, atom.args[0]] ), new Term( "=", [rule.body, atom.args[1]] )] ); + states.push( new State( point.goal.replace( goal ), point.substitution, point ) ); + } + thread.prepend( states ); + } else { + thread.throw_error( pl.error.permission( "access", "private_procedure", atom.args[0].indicator, atom.indicator ) ); + } + } + }, + + // current_predicate/1 + "current_predicate/1": function( thread, point, atom ) { + var indicator = atom.args[0]; + if( !pl.type.is_variable( indicator ) && (!pl.type.is_compound( indicator ) || indicator.indicator !== "//2") ) { + thread.throw_error( pl.error.type( "predicate_indicator", indicator, atom.indicator ) ); + } else if( !pl.type.is_variable( indicator ) && !pl.type.is_variable( indicator.args[0] ) && !pl.type.is_atom( indicator.args[0] ) ) { + thread.throw_error( pl.error.type( "atom", indicator.args[0], atom.indicator ) ); + } else if( !pl.type.is_variable( indicator ) && !pl.type.is_variable( indicator.args[1] ) && !pl.type.is_integer( indicator.args[1] ) ) { + thread.throw_error( pl.error.type( "integer", indicator.args[1], atom.indicator ) ); + } else { + var states = []; + for( var i in thread.session.rules ) { + if(!thread.session.rules.hasOwnProperty(i)) continue; + var index = i.lastIndexOf( "/" ); + var name = i.substr( 0, index ); + var arity = parseInt( i.substr( index+1, i.length-(index+1) ) ); + var predicate = new Term( "/", [new Term( name ), new Num( arity, false )] ); + var goal = new Term( "=", [predicate, indicator] ); + states.push( new State( point.goal.replace( goal ), point.substitution, point ) ); + } + thread.prepend( states ); + } + }, + + // CLAUSE CREATION AND DESTRUCTION + + // asserta/1 + "asserta/1": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( atom.args[0] ) ) { + thread.throw_error( pl.error.type( "callable", atom.args[0], atom.indicator ) ); + } else { + var head, body; + if( atom.args[0].indicator === ":-/2" ) { + head = atom.args[0].args[0]; + body = body_conversion( atom.args[0].args[1] ); + } else { + head = atom.args[0]; + body = null; + } + if( !pl.type.is_callable( head ) ) { + thread.throw_error( pl.error.type( "callable", head, atom.indicator ) ); + } else if( body !== null && !pl.type.is_callable( body ) ) { + thread.throw_error( pl.error.type( "callable", body, atom.indicator ) ); + } else if( thread.is_public_predicate( head.indicator ) ) { + if( thread.session.rules[head.indicator] === undefined ) { + thread.session.rules[head.indicator] = []; + } + thread.session.public_predicates[head.indicator] = true; + thread.session.rules[head.indicator] = [new Rule( head, body, true )].concat( thread.session.rules[head.indicator] ); + thread.success( point ); + } else { + thread.throw_error( pl.error.permission( "modify", "static_procedure", head.indicator, atom.indicator ) ); + } + } + }, + + // assertz/1 + "assertz/1": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( atom.args[0] ) ) { + thread.throw_error( pl.error.type( "callable", atom.args[0], atom.indicator ) ); + } else { + var head, body; + if( atom.args[0].indicator === ":-/2" ) { + head = atom.args[0].args[0]; + body = body_conversion( atom.args[0].args[1] ); + } else { + head = atom.args[0]; + body = null; + } + if( !pl.type.is_callable( head ) ) { + thread.throw_error( pl.error.type( "callable", head, atom.indicator ) ); + } else if( body !== null && !pl.type.is_callable( body ) ) { + thread.throw_error( pl.error.type( "callable", body, atom.indicator ) ); + } else if( thread.is_public_predicate( head.indicator ) ) { + if( thread.session.rules[head.indicator] === undefined ) { + thread.session.rules[head.indicator] = []; + } + thread.session.public_predicates[head.indicator] = true; + thread.session.rules[head.indicator].push( new Rule( head, body, true ) ); + thread.success( point ); + } else { + thread.throw_error( pl.error.permission( "modify", "static_procedure", head.indicator, atom.indicator ) ); + } + } + }, + + // retract/1 + "retract/1": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( atom.args[0] ) ) { + thread.throw_error( pl.error.type( "callable", atom.args[0], atom.indicator ) ); + } else { + var head, body; + if( atom.args[0].indicator === ":-/2" ) { + head = atom.args[0].args[0]; + body = atom.args[0].args[1]; + } else { + head = atom.args[0]; + body = new Term( "true" ); + } + if( typeof point.retract === "undefined" ) { + if( thread.is_public_predicate( head.indicator ) ) { + if( thread.session.rules[head.indicator] !== undefined ) { + var states = []; + for( var i = 0; i < thread.session.rules[head.indicator].length; i++ ) { + thread.session.renamed_variables = {}; + var orule = thread.session.rules[head.indicator][i]; + var rule = orule.rename( thread ); + if( rule.body === null ) + rule.body = new Term( "true", [] ); + var occurs_check = thread.get_flag( "occurs_check" ).indicator === "true/0"; + var mgu = pl.unify( new Term( ",", [head, body] ), new Term( ",", [rule.head, rule.body] ), occurs_check ); + if( mgu !== null ) { + var state = new State( point.goal.replace( new Term(",", [ + new Term( "retract", [ new Term( ":-", [head, body] ) ] ), + new Term( ",", [ + new Term( "=", [head, rule.head] ), + new Term( "=", [body, rule.body] ) + ] ) + ] ) ), point.substitution, point ); + state.retract = orule; + states.push( state ); + } + } + thread.prepend( states ); + } + } else { + thread.throw_error( pl.error.permission( "modify", "static_procedure", head.indicator, atom.indicator ) ); + } + } else { + retract( thread, point, head.indicator, point.retract ); + } + } + }, + + // retractall/1 + "retractall/1": function( thread, point, atom ) { + var head = atom.args[0]; + if( pl.type.is_variable( head ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_callable( head ) ) { + thread.throw_error( pl.error.type( "callable", head, atom.indicator ) ); + } else { + thread.prepend( [ + new State( point.goal.replace( new Term( ",", [ + new Term( "retract", [new pl.type.Term( ":-", [head, new Var( "_" )] )] ), + new Term( "fail", [] ) + ] ) ), point.substitution, point ), + new State( point.goal.replace( null ), point.substitution, point ) + ] ); + } + }, + + // abolish/1 + "abolish/1": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) || pl.type.is_term( atom.args[0] ) && atom.args[0].indicator === "//2" + && (pl.type.is_variable( atom.args[0].args[0] ) || pl.type.is_variable( atom.args[0].args[1] )) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_term( atom.args[0] ) || atom.args[0].indicator !== "//2" ) { + thread.throw_error( pl.error.type( "predicate_indicator", atom.args[0], atom.indicator ) ); + } else if( !pl.type.is_atom( atom.args[0].args[0] ) ) { + thread.throw_error( pl.error.type( "atom", atom.args[0].args[0], atom.indicator ) ); + } else if( !pl.type.is_integer( atom.args[0].args[1] ) ) { + thread.throw_error( pl.error.type( "integer", atom.args[0].args[1], atom.indicator ) ); + } else if( atom.args[0].args[1].value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", atom.args[0].args[1], atom.indicator ) ); + } else if( pl.type.is_number(thread.get_flag( "max_arity" )) && atom.args[0].args[1].value > thread.get_flag( "max_arity" ).value ) { + thread.throw_error( pl.error.representation( "max_arity", atom.indicator ) ); + } else { + var indicator = atom.args[0].args[0].id + "/" + atom.args[0].args[1].value; + if( thread.is_public_predicate( indicator ) ) { + delete thread.session.rules[indicator]; + thread.success( point ); + } else { + thread.throw_error( pl.error.permission( "modify", "static_procedure", indicator, atom.indicator ) ); + } + } + }, + + // ATOM PROCESSING + + // atom_length/2 + "atom_length/2": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( atom.args[0] ) ) { + thread.throw_error( pl.error.type( "atom", atom.args[0], atom.indicator ) ); + } else if( !pl.type.is_variable( atom.args[1] ) && !pl.type.is_integer( atom.args[1] ) ) { + thread.throw_error( pl.error.type( "integer", atom.args[1], atom.indicator ) ); + } else if( pl.type.is_integer( atom.args[1] ) && atom.args[1].value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", atom.args[1], atom.indicator ) ); + } else { + var length = new Num( atom.args[0].id.length, false ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [length, atom.args[1]] ) ), point.substitution, point )] ); + } + }, + + // atom_concat/3 + "atom_concat/3": function( thread, point, atom ) { + var str, goal, start = atom.args[0], end = atom.args[1], whole = atom.args[2]; + if( pl.type.is_variable( whole ) && (pl.type.is_variable( start ) || pl.type.is_variable( end )) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( start ) && !pl.type.is_atom( start ) ) { + thread.throw_error( pl.error.type( "atom", start, atom.indicator ) ); + } else if( !pl.type.is_variable( end ) && !pl.type.is_atom( end ) ) { + thread.throw_error( pl.error.type( "atom", end, atom.indicator ) ); + } else if( !pl.type.is_variable( whole ) && !pl.type.is_atom( whole ) ) { + thread.throw_error( pl.error.type( "atom", whole, atom.indicator ) ); + } else { + var v1 = pl.type.is_variable( start ); + var v2 = pl.type.is_variable( end ); + //var v3 = pl.type.is_variable( whole ); + if( !v1 && !v2 ) { + goal = new Term( "=", [whole, new Term( start.id + end.id )] ); + thread.prepend( [new State( point.goal.replace( goal ), point.substitution, point )] ); + } else if( v1 && !v2 ) { + str = whole.id.substr( 0, whole.id.length - end.id.length ); + if( str + end.id === whole.id ) { + goal = new Term( "=", [start, new Term( str )] ); + thread.prepend( [new State( point.goal.replace( goal ), point.substitution, point )] ); + } + } else if( v2 && !v1 ) { + str = whole.id.substr( start.id.length ); + if( start.id + str === whole.id ) { + goal = new Term( "=", [end, new Term( str )] ); + thread.prepend( [new State( point.goal.replace( goal ), point.substitution, point )] ); + } + } else { + var states = []; + for( var i = 0; i <= whole.id.length; i++ ) { + var atom1 = new Term( whole.id.substr( 0, i ) ); + var atom2 = new Term( whole.id.substr( i ) ); + goal = new Term( ",", [new Term( "=", [atom1, start] ), new Term( "=", [atom2, end] )] ); + states.push( new State( point.goal.replace( goal ), point.substitution, point ) ); + } + thread.prepend( states ); + } + } + }, + + // sub_atom/5 + "sub_atom/5": function( thread, point, atom ) { + var i, atom1 = atom.args[0], before = atom.args[1], length = atom.args[2], after = atom.args[3], subatom = atom.args[4]; + if( pl.type.is_variable( atom1 ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( before ) && !pl.type.is_integer( before ) ) { + thread.throw_error( pl.error.type( "integer", before, atom.indicator ) ); + } else if( !pl.type.is_variable( length ) && !pl.type.is_integer( length ) ) { + thread.throw_error( pl.error.type( "integer", length, atom.indicator ) ); + } else if( !pl.type.is_variable( after ) && !pl.type.is_integer( after ) ) { + thread.throw_error( pl.error.type( "integer", after, atom.indicator ) ); + } else if( pl.type.is_integer( before ) && before.value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", before, atom.indicator ) ); + } else if( pl.type.is_integer( length ) && length.value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", length, atom.indicator ) ); + } else if( pl.type.is_integer( after ) && after.value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", after, atom.indicator ) ); + } else { + var bs = [], ls = [], as = []; + if( pl.type.is_variable( before ) ) { + for( i = 0; i <= atom1.id.length; i++ ) { + bs.push( i ); + } + } else { + bs.push( before.value ); + } + if( pl.type.is_variable( length ) ) { + for( i = 0; i <= atom1.id.length; i++ ) { + ls.push( i ); + } + } else { + ls.push( length.value ); + } + if( pl.type.is_variable( after ) ) { + for( i = 0; i <= atom1.id.length; i++ ) { + as.push( i ); + } + } else { + as.push( after.value ); + } + var states = []; + for( var _i in bs ) { + if(!bs.hasOwnProperty(_i)) continue; + i = bs[_i]; + for( var _j in ls ) { + if(!ls.hasOwnProperty(_j)) continue; + var j = ls[_j]; + var k = atom1.id.length - i - j; + if( indexOf( as, k ) !== -1 ) { + if( i+j+k === atom1.id.length ) { + var str = atom1.id.substr( i, j ); + if( atom1.id === atom1.id.substr( 0, i ) + str + atom1.id.substr( i+j, k ) ) { + var pl1 = new Term( "=", [new Term( str ), subatom] ); + var pl2 = new Term( "=", [before, new Num( i )] ); + var pl3 = new Term( "=", [length, new Num( j )] ); + var pl4 = new Term( "=", [after, new Num( k )] ); + var goal = new Term( ",", [ new Term( ",", [ new Term( ",", [pl2, pl3] ), pl4] ), pl1] ); + states.push( new State( point.goal.replace( goal ), point.substitution, point ) ); + } + } + } + } + } + thread.prepend( states ); + } + }, + + // atom_chars/2 + "atom_chars/2": function( thread, point, atom ) { + var atom1 = atom.args[0], list = atom.args[1]; + if( pl.type.is_variable( atom1 ) && pl.type.is_variable( list ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( atom1 ) && !pl.type.is_atom( atom1 ) ) { + thread.throw_error( pl.error.type( "atom", atom1, atom.indicator ) ); + } else { + if( !pl.type.is_variable( atom1 ) ) { + var list1 = new Term( "[]" ); + for( var i = atom1.id.length-1; i >= 0; i-- ) { + list1 = new Term( ".", [new Term( atom1.id.charAt( i ) ), list1] ); + } + thread.prepend( [new State( point.goal.replace( new Term( "=", [list, list1] ) ), point.substitution, point )] ); + } else { + var pointer = list; + var v = pl.type.is_variable( atom1 ); + var str = ""; + while( pointer.indicator === "./2" ) { + if( !pl.type.is_character( pointer.args[0] ) ) { + if( pl.type.is_variable( pointer.args[0] ) && v ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( !pl.type.is_variable( pointer.args[0] ) ) { + thread.throw_error( pl.error.type( "character", pointer.args[0], atom.indicator ) ); + return; + } + } else { + str += pointer.args[0].id; + } + pointer = pointer.args[1]; + } + if( pl.type.is_variable( pointer ) && v ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_empty_list( pointer ) && !pl.type.is_variable( pointer ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [new Term( str ), atom1] ) ), point.substitution, point )] ); + } + } + } + }, + + // atom_codes/2 + "atom_codes/2": function( thread, point, atom ) { + var atom1 = atom.args[0], list = atom.args[1]; + if( pl.type.is_variable( atom1 ) && pl.type.is_variable( list ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( atom1 ) && !pl.type.is_atom( atom1 ) ) { + thread.throw_error( pl.error.type( "atom", atom1, atom.indicator ) ); + } else { + if( !pl.type.is_variable( atom1 ) ) { + var list1 = new Term( "[]" ); + for( var i = atom1.id.length-1; i >= 0; i-- ) { + list1 = new Term( ".", [new Num( codePointAt(atom1.id,i), false ), list1] ); + } + thread.prepend( [new State( point.goal.replace( new Term( "=", [list, list1] ) ), point.substitution, point )] ); + } else { + var pointer = list; + var v = pl.type.is_variable( atom1 ); + var str = ""; + while( pointer.indicator === "./2" ) { + if( !pl.type.is_character_code( pointer.args[0] ) ) { + if( pl.type.is_variable( pointer.args[0] ) && v ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( !pl.type.is_variable( pointer.args[0] ) ) { + thread.throw_error( pl.error.representation( "character_code", atom.indicator ) ); + return; + } + } else { + str += fromCodePoint( pointer.args[0].value ); + } + pointer = pointer.args[1]; + } + if( pl.type.is_variable( pointer ) && v ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_empty_list( pointer ) && !pl.type.is_variable( pointer ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [new Term( str ), atom1] ) ), point.substitution, point )] ); + } + } + } + }, + + // char_code/2 + "char_code/2": function( thread, point, atom ) { + var char = atom.args[0], code = atom.args[1]; + if( pl.type.is_variable( char ) && pl.type.is_variable( code ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( char ) && !pl.type.is_character( char ) ) { + thread.throw_error( pl.error.type( "character", char, atom.indicator ) ); + } else if( !pl.type.is_variable( code ) && !pl.type.is_integer( code ) ) { + thread.throw_error( pl.error.type( "integer", code, atom.indicator ) ); + } else if( !pl.type.is_variable( code ) && !pl.type.is_character_code( code ) ) { + thread.throw_error( pl.error.representation( "character_code", atom.indicator ) ); + } else { + if( pl.type.is_variable( code ) ) { + var code1 = new Num( codePointAt(char.id,0 ), false ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [code1, code] ) ), point.substitution, point )] ); + } else { + var char1 = new Term( fromCodePoint( code.value ) ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [char1, char] ) ), point.substitution, point )] ); + } + } + }, + + // number_chars/2 + "number_chars/2": function( thread, point, atom ) { + var str, num = atom.args[0], list = atom.args[1]; + if( pl.type.is_variable( num ) && pl.type.is_variable( list ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( num ) && !pl.type.is_number( num ) ) { + thread.throw_error( pl.error.type( "number", num, atom.indicator ) ); + } else if( !pl.type.is_variable( list ) && !pl.type.is_list( list ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + } else { + var isvar = pl.type.is_variable( num ); + if( !pl.type.is_variable( list ) ) { + var pointer = list; + var total = true; + str = ""; + while( pointer.indicator === "./2" ) { + if( !pl.type.is_character( pointer.args[0] ) ) { + if( pl.type.is_variable( pointer.args[0] ) ) { + total = false; + } else if( !pl.type.is_variable( pointer.args[0] ) ) { + thread.throw_error( pl.error.type( "character", pointer.args[0], atom.indicator ) ); + return; + } + } else { + str += pointer.args[0].id; + } + pointer = pointer.args[1]; + } + total = total && pl.type.is_empty_list( pointer ); + if( !pl.type.is_empty_list( pointer ) && !pl.type.is_variable( pointer ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + return; + } + if( !total && isvar ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( total ) { + if( pl.type.is_variable( pointer ) && isvar ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else { + var expr = thread.parse( str ); + var num2 = expr.value; + if( !pl.type.is_number( num2 ) || expr.tokens[expr.tokens.length-1].space ) { + thread.throw_error( pl.error.syntax_by_predicate( "parseable_number", atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [num, num2] ) ), point.substitution, point )] ); + } + return; + } + } + } + if( !isvar ) { + str = num.toString(); + var list2 = new Term( "[]" ); + for( var i = str.length - 1; i >= 0; i-- ) { + list2 = new Term( ".", [ new Term( str.charAt( i ) ), list2 ] ); + } + thread.prepend( [new State( point.goal.replace( new Term( "=", [list, list2] ) ), point.substitution, point )] ); + } + } + }, + + // number_codes/2 + "number_codes/2": function( thread, point, atom ) { + var str, num = atom.args[0], list = atom.args[1]; + if( pl.type.is_variable( num ) && pl.type.is_variable( list ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( num ) && !pl.type.is_number( num ) ) { + thread.throw_error( pl.error.type( "number", num, atom.indicator ) ); + } else if( !pl.type.is_variable( list ) && !pl.type.is_list( list ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + } else { + var isvar = pl.type.is_variable( num ); + if( !pl.type.is_variable( list ) ) { + var pointer = list; + var total = true; + str = ""; + while( pointer.indicator === "./2" ) { + if( !pl.type.is_character_code( pointer.args[0] ) ) { + if( pl.type.is_variable( pointer.args[0] ) ) { + total = false; + } else if( !pl.type.is_variable( pointer.args[0] ) ) { + thread.throw_error( pl.error.type( "character_code", pointer.args[0], atom.indicator ) ); + return; + } + } else { + str += fromCodePoint( pointer.args[0].value ); + } + pointer = pointer.args[1]; + } + total = total && pl.type.is_empty_list( pointer ); + if( !pl.type.is_empty_list( pointer ) && !pl.type.is_variable( pointer ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + return; + } + if( !total && isvar ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( total ) { + if( pl.type.is_variable( pointer ) && isvar ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else { + var expr = thread.parse( str ); + var num2 = expr.value; + if( !pl.type.is_number( num2 ) || expr.tokens[expr.tokens.length-1].space ) { + thread.throw_error( pl.error.syntax_by_predicate( "parseable_number", atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [num, num2] ) ), point.substitution, point )] ); + } + return; + } + } + } + if( !isvar ) { + str = num.toString(); + var list2 = new Term( "[]" ); + for( var i = str.length - 1; i >= 0; i-- ) { + list2 = new Term( ".", [ new Num( codePointAt(str,i), false ), list2 ] ); + } + thread.prepend( [new State( point.goal.replace( new Term( "=", [list, list2] ) ), point.substitution, point )] ); + } + } + }, + + // upcase_atom/2 + "upcase_atom/2": function( thread, point, atom ) { + var original = atom.args[0], upcase = atom.args[1]; + if( pl.type.is_variable( original ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( original ) ) { + thread.throw_error( pl.error.type( "atom", original, atom.indicator ) ); + } else if( !pl.type.is_variable( upcase ) && !pl.type.is_atom( upcase ) ) { + thread.throw_error( pl.error.type( "atom", upcase, atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [upcase, new Term( original.id.toUpperCase(), [] )] ) ), point.substitution, point )] ); + } + }, + + // downcase_atom/2 + "downcase_atom/2": function( thread, point, atom ) { + var original = atom.args[0], downcase = atom.args[1]; + if( pl.type.is_variable( original ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( original ) ) { + thread.throw_error( pl.error.type( "atom", original, atom.indicator ) ); + } else if( !pl.type.is_variable( downcase ) && !pl.type.is_atom( downcase ) ) { + thread.throw_error( pl.error.type( "atom", downcase, atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [downcase, new Term( original.id.toLowerCase(), [] )] ) ), point.substitution, point )] ); + } + }, + + // atomic_list_concat/2 + "atomic_list_concat/2": function( thread, point, atom ) { + var list = atom.args[0], concat = atom.args[1]; + thread.prepend( [new State( point.goal.replace( new Term( "atomic_list_concat", [list, new Term( "", [] ), concat] ) ), point.substitution, point )] ); + }, + + // atomic_list_concat/3 + "atomic_list_concat/3": function( thread, point, atom ) { + var list = atom.args[0], separator = atom.args[1], concat = atom.args[2]; + if( pl.type.is_variable( separator ) || pl.type.is_variable( list ) && pl.type.is_variable( concat ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( list ) && !pl.type.is_list( list ) ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + } else if( !pl.type.is_variable( concat ) && !pl.type.is_atom( concat ) ) { + thread.throw_error( pl.error.type( "atom", concat, atom.indicator ) ); + } else { + if( !pl.type.is_variable( concat ) ) { + var atomic = arrayToList( map( + concat.id.split( separator.id ), + function( id ) { + return new Term( id, [] ); + } + ) ); + thread.prepend( [new State( point.goal.replace( new Term( "=", [atomic, list] ) ), point.substitution, point )] ); + } else { + var id = ""; + var pointer = list; + while( pl.type.is_term( pointer ) && pointer.indicator === "./2" ) { + if( !pl.type.is_atom( pointer.args[0] ) && !pl.type.is_number( pointer.args[0] ) ) { + thread.throw_error( pl.error.type( "atomic", pointer.args[0], atom.indicator ) ); + return; + } + if( id !== "" ) + id += separator.id; + if( pl.type.is_atom( pointer.args[0] ) ) + id += pointer.args[0].id; + else + id += "" + pointer.args[0].value; + pointer = pointer.args[1]; + } + id = new Term( id, [] ); + if( pl.type.is_variable( pointer ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_term( pointer ) || pointer.indicator !== "[]/0" ) { + thread.throw_error( pl.error.type( "list", list, atom.indicator ) ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [id, concat] ) ), point.substitution, point )] ); + } + } + } + }, + + // TERM COMPARISON + + "@=/2": function( thread, point, atom ) { + if( pl.compare( atom.args[0], atom.args[1] ) > 0 ) { + thread.success( point ); + } + }, + + "@>=/2": function( thread, point, atom ) { + if( pl.compare( atom.args[0], atom.args[1] ) >= 0 ) { + thread.success( point ); + } + }, + + "compare/3": function( thread, point, atom ) { + var order = atom.args[0], left = atom.args[1], right = atom.args[2]; + if( !pl.type.is_variable( order ) && !pl.type.is_atom( order ) ) { + thread.throw_error( pl.error.type( "atom", order, atom.indicator ) ); + } else if( pl.type.is_atom( order ) && ["<", ">", "="].indexOf( order.id ) === -1 ) { + thread.throw_error( pl.type.domain( "order", order, atom.indicator ) ); + } else { + var compare = pl.compare( left, right ); + compare = compare === 0 ? "=" : (compare === -1 ? "<" : ">"); + thread.prepend( [new State( point.goal.replace( new Term( "=", [order, new Term( compare, [] )] ) ), point.substitution, point )] ); + } + }, + + // EVALUATION + + // is/2 + "is/2": function( thread, point, atom ) { + var op = atom.args[1].interpret( thread ); + if( !pl.type.is_number( op ) ) { + thread.throw_error( op ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [atom.args[0], op], thread.level ) ), point.substitution, point )] ); + } + }, + + // between/3 + "between/3": function( thread, point, atom ) { + var lower = atom.args[0], upper = atom.args[1], bet = atom.args[2]; + if( pl.type.is_variable( lower ) || pl.type.is_variable( upper ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_integer( lower ) ) { + thread.throw_error( pl.error.type( "integer", lower, atom.indicator ) ); + } else if( !pl.type.is_integer( upper ) ) { + thread.throw_error( pl.error.type( "integer", upper, atom.indicator ) ); + } else if( !pl.type.is_variable( bet ) && !pl.type.is_integer( bet ) ) { + thread.throw_error( pl.error.type( "integer", bet, atom.indicator ) ); + } else { + if( pl.type.is_variable( bet ) ) { + var states = [new State( point.goal.replace( new Term( "=", [bet, lower] ) ), point.substitution, point )]; + if( lower.value < upper.value ) + states.push( new State( point.goal.replace( new Term( "between", [new Num( lower.value+1, false ), upper, bet] ) ), point.substitution, point ) ); + thread.prepend( states ); + } else if( lower.value <= bet.value && upper.value >= bet.value ) { + thread.success( point ); + } + } + }, + + // succ/2 + "succ/2": function( thread, point, atom ) { + var n = atom.args[0], m = atom.args[1]; + if( pl.type.is_variable( n ) && pl.type.is_variable( m ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( n ) && !pl.type.is_integer( n ) ) { + thread.throw_error( pl.error.type( "integer", n, atom.indicator ) ); + } else if( !pl.type.is_variable( m ) && !pl.type.is_integer( m ) ) { + thread.throw_error( pl.error.type( "integer", m, atom.indicator ) ); + } else if( !pl.type.is_variable( n ) && n.value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", n, atom.indicator ) ); + } else if( !pl.type.is_variable( m ) && m.value < 0 ) { + thread.throw_error( pl.error.domain( "not_less_than_zero", m, atom.indicator ) ); + } else { + if( pl.type.is_variable( m ) || m.value > 0 ) { + if( pl.type.is_variable( n ) ) { + thread.prepend( [new State( point.goal.replace( new Term( "=", [n, new Num( m.value-1, false )] ) ), point.substitution, point )] ); + } else { + thread.prepend( [new State( point.goal.replace( new Term( "=", [m, new Num( n.value+1, false )] ) ), point.substitution, point )] ); + } + } + } + }, + + // =:=/2 + "=:=/2": function( thread, point, atom ) { + var cmp = pl.arithmetic_compare( thread, atom.args[0], atom.args[1] ); + if( pl.type.is_term( cmp ) ) { + thread.throw_error( cmp ); + } else if( cmp === 0 ) { + thread.success( point ); + } + }, + + // =\=/2 + "=\\=/2": function( thread, point, atom ) { + var cmp = pl.arithmetic_compare( thread, atom.args[0], atom.args[1] ); + if( pl.type.is_term( cmp ) ) { + thread.throw_error( cmp ); + } else if( cmp !== 0 ) { + thread.success( point ); + } + }, + + // /2 + ">/2": function( thread, point, atom ) { + var cmp = pl.arithmetic_compare( thread, atom.args[0], atom.args[1] ); + if( pl.type.is_term( cmp ) ) { + thread.throw_error( cmp ); + } else if( cmp > 0 ) { + thread.success( point ); + } + }, + + // >=/2 + ">=/2": function( thread, point, atom ) { + var cmp = pl.arithmetic_compare( thread, atom.args[0], atom.args[1] ); + if( pl.type.is_term( cmp ) ) { + thread.throw_error( cmp ); + } else if( cmp >= 0 ) { + thread.success( point ); + } + }, + + // TYPE TEST + + // var/1 + "var/1": function( thread, point, atom ) { + if( pl.type.is_variable( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // atom/1 + "atom/1": function( thread, point, atom ) { + if( pl.type.is_atom( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // atomic/1 + "atomic/1": function( thread, point, atom ) { + if( pl.type.is_atomic( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // compound/1 + "compound/1": function( thread, point, atom ) { + if( pl.type.is_compound( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // integer/1 + "integer/1": function( thread, point, atom ) { + if( pl.type.is_integer( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // float/1 + "float/1": function( thread, point, atom ) { + if( pl.type.is_float( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // number/1 + "number/1": function( thread, point, atom ) { + if( pl.type.is_number( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // nonvar/1 + "nonvar/1": function( thread, point, atom ) { + if( !pl.type.is_variable( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // ground/1 + "ground/1": function( thread, point, atom ) { + if( atom.variables().length === 0 ) { + thread.success( point ); + } + }, + + // acyclic_term/1 + "acyclic_term/1": function( thread, point, atom ) { + var test = point.substitution.apply( point.substitution ); + var variables = atom.args[0].variables(); + for( var i = 0; i < variables.length; i++ ) + if( point.substitution.links[variables[i]] !== undefined && !point.substitution.links[variables[i]].equals( test.links[variables[i]] ) ) + return; + thread.success( point ); + }, + + // callable/1 + "callable/1": function( thread, point, atom ) { + if( pl.type.is_callable( atom.args[0] ) ) { + thread.success( point ); + } + }, + + // is_list/1 + "is_list/1": function( thread, point, atom ) { + var list = atom.args[0]; + while( pl.type.is_term( list ) && list.indicator === "./2" ) + list = list.args[1]; + if( pl.type.is_term( list ) && list.indicator === "[]/0" ) + thread.success( point ); + }, + + + + // STREAM SELECTION AND CONTROL + + // current_input/1 + "current_input/1": function( thread, point, atom ) { + var stream = atom.args[0]; + if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain("stream", stream, atom.indicator) ); + } else { + if( pl.type.is_atom( stream ) && thread.get_stream_by_alias( stream.id ) ) + stream = thread.get_stream_by_alias( stream.id ); + thread.prepend( [new State( + point.goal.replace(new Term("=", [stream, thread.get_current_input()])), + point.substitution, + point) + ] ); + } + }, + + // current_output/1 + "current_output/1": function( thread, point, atom ) { + var stream = atom.args[0]; + if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain("stream_or_alias", stream, atom.indicator) ); + } else { + if( pl.type.is_atom( stream ) && thread.get_stream_by_alias( stream.id ) ) + stream = thread.get_stream_by_alias( stream.id ); + thread.prepend( [new State( + point.goal.replace(new Term("=", [stream, thread.get_current_output()])), + point.substitution, + point) + ] ); + } + }, + + // set_input/1 + "set_input/1": function( thread, point, atom ) { + var input = atom.args[0]; + var stream = pl.type.is_stream( input ) ? input : thread.get_stream_by_alias( input.id ); + if( pl.type.is_variable( input ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( input ) && !pl.type.is_stream( input ) && !pl.type.is_atom( input ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", input, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) ) { + thread.throw_error( pl.error.existence( "stream", input, atom.indicator ) ); + } else if( stream.output === true ) { + thread.throw_error( pl.error.permission( "input", "stream", input, atom.indicator ) ); + } else { + thread.set_current_input( stream ); + thread.success( point ); + } + }, + + // set_output/1 + "set_output/1": function( thread, point, atom ) { + var output = atom.args[0]; + var stream = pl.type.is_stream( output ) ? output : thread.get_stream_by_alias( output.id ); + if( pl.type.is_variable( output ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( output ) && !pl.type.is_stream( output ) && !pl.type.is_atom( output ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", output, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) ) { + thread.throw_error( pl.error.existence( "stream", output, atom.indicator ) ); + } else if( stream.input === true ) { + thread.throw_error( pl.error.permission( "output", "stream", output, atom.indicator ) ); + } else { + thread.set_current_output( stream ); + thread.success( point ); + } + }, + + // open/3 + "open/3": function( thread, point, atom ) { + var dest = atom.args[0], mode = atom.args[1], stream = atom.args[2]; + thread.prepend( [new State( + point.goal.replace(new Term("open", [dest, mode, stream, new Term("[]", [])])), + point.substitution, + point + )] ); + }, + + // open/4 + "open/4": function( thread, point, atom ) { + var dest = atom.args[0], mode = atom.args[1], stream = atom.args[2], options = atom.args[3]; + if( pl.type.is_variable( dest ) || pl.type.is_variable( mode ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( mode ) && !pl.type.is_atom( mode ) ) { + thread.throw_error( pl.error.type( "atom", mode, atom.indicator ) ); + } else if( !pl.type.is_list( options ) ) { + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.type( "variable", stream, atom.indicator ) ); + } else if( !pl.type.is_atom( dest ) && !pl.type.is_streamable( dest ) ) { + thread.throw_error( pl.error.domain( "source_sink", dest, atom.indicator ) ); + } else if( !pl.type.is_io_mode( mode ) ) { + thread.throw_error( pl.error.domain( "io_mode", mode, atom.indicator ) ); + } else { + var obj_options = {}; + var pointer = options; + var property; + while( pl.type.is_term(pointer) && pointer.indicator === "./2" ) { + property = pointer.args[0]; + if( pl.type.is_variable( property ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( !pl.type.is_stream_option( property ) ) { + thread.throw_error( pl.error.domain( "stream_option", property, atom.indicator ) ); + return; + } + obj_options[property.id] = property.args[0].id; + pointer = pointer.args[1]; + } + if( pointer.indicator !== "[]/0" ) { + if( pl.type.is_variable( pointer ) ) + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + else + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + return; + } else { + var alias = obj_options["alias"]; + if( alias && thread.get_stream_by_alias(alias) ) { + thread.throw_error( pl.error.permission( "open", "source_sink", new Term("alias", [new Term(alias, [])]), atom.indicator ) ); + return; + } + if( !obj_options["type"] ) + obj_options["type"] = "text"; + var file; + if( pl.type.is_atom( dest ) ) + file = thread.file_system_open( dest.id, obj_options["type"], mode.id ); + else + file = dest.stream( obj_options["type"], mode.id ); + if( file === false ) { + thread.throw_error( pl.error.permission( "open", "source_sink", dest, atom.indicator ) ); + return; + } else if( file === null ) { + thread.throw_error( pl.error.existence( "source_sink", dest, atom.indicator ) ); + return; + } + var newstream = new Stream( + file, mode.id, + obj_options["alias"], + obj_options["type"], + obj_options["reposition"] === "true", + obj_options["eof_action"] ); + if( alias ) + thread.session.streams[alias] = newstream; + else + thread.session.streams[newstream.id] = newstream; + thread.prepend( [new State( + point.goal.replace( new Term( "=", [stream, newstream] ) ), + point.substitution, + point + )] ); + } + } + }, + + // close/1 + "close/1": function( thread, point, atom ) { + var stream = atom.args[0]; + thread.prepend( [new State( + point.goal.replace(new Term("close", [stream, new Term("[]", [])])), + point.substitution, + point + )] ); + }, + + // close/2 + "close/2": function( thread, point, atom ) { + var stream = atom.args[0], options = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( options ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_list( options ) ) { + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else { + // Get options + var obj_options = {}; + var pointer = options; + var property; + while( pl.type.is_term(pointer) && pointer.indicator === "./2" ) { + property = pointer.args[0]; + if( pl.type.is_variable( property ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( !pl.type.is_close_option( property ) ) { + thread.throw_error( pl.error.domain( "close_option", property, atom.indicator ) ); + return; + } + obj_options[property.id] = property.args[0].id === "true"; + pointer = pointer.args[1]; + } + if( pointer.indicator !== "[]/0" ) { + if( pl.type.is_variable( pointer ) ) + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + else + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + return; + } else { + if( stream2 === thread.session.standard_input || stream2 === thread.session.standard_output ) { + thread.success( point ); + return; + } else if( stream2 === thread.session.current_input ) { + thread.session.current_input = thread.session.standard_input; + } else if( stream2 === thread.session.current_output ) { + thread.session.current_output = thread.session.current_output; + } + if( stream2.alias !== null ) + delete thread.session.streams[stream2.alias]; + else + delete thread.session.streams[stream2.id]; + if( stream2.output ) + stream2.stream.flush(); + var closed = stream2.stream.close(); + stream2.stream = null; + if( obj_options.force === true || closed === true ) { + thread.success( point ); + } + } + } + }, + + // flush_output/0 + "flush_output/0": function( thread, point, atom ) { + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("flush_output", [new Var("S")])]) ), + point.substitution, + point + )] ); + }, + + // flush_output/1 + "flush_output/1": function( thread, point, atom ) { + var stream = atom.args[0]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream.input === true ) { + thread.throw_error( pl.error.permission( "output", "stream", output, atom.indicator ) ); + } else { + stream2.stream.flush(); + thread.success( point ); + } + }, + + // stream_property/2 + "stream_property/2": function( thread, point, atom ) { + var stream = atom.args[0], property = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) && (!pl.type.is_stream( stream2 ) || stream2.stream === null) ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( !pl.type.is_variable( property ) && !pl.type.is_stream_property( property ) ) { + thread.throw_error( pl.error.domain( "stream_property", property, atom.indicator ) ); + } else { + var streams = []; + var states = []; + if( !pl.type.is_variable( stream ) ) + streams.push( stream2 ); + else + for( var key in thread.session.streams ) + streams.push( thread.session.streams[key] ); + for( var i = 0; i < streams.length; i++ ) { + var properties = []; + if( streams[i].filename ) + properties.push( new Term( "file_name", [new Term(streams[i].file_name, [])] ) ); + properties.push( new Term( "mode", [new Term(streams[i].mode, [])] ) ); + properties.push( new Term( streams[i].input ? "input" : "output", [] ) ); + if( streams[i].alias ) + properties.push( new Term( "alias", [new Term(streams[i].alias, [])] ) ); + properties.push( new Term( "position", [ + typeof streams[i].position === "number" ? + new Num( streams[i].position, false ) : + new Term( streams[i].position, [] ) + ] ) ); + properties.push( new Term( "end_of_stream", [new Term( + streams[i].position === "end_of_stream" ? "at" : + streams[i].position === "past_end_of_stream" ? "past" : + "not", [])] ) ); + properties.push( new Term( "eof_action", [new Term(streams[i].eof_action, [])] ) ); + properties.push( new Term( "reposition", [new Term(streams[i].reposition ? "true" : "false", [])] ) ); + properties.push( new Term( "type", [new Term(streams[i].type, [])] ) ); + for( var j = 0; j < properties.length; j++ ) { + states.push( new State( + point.goal.replace( new Term( ",", [ + new Term("=", [pl.type.is_variable( stream ) ? stream : stream2, streams[i]]), + new Term("=", [property, properties[j]])]) ), + point.substitution, + point + ) ); + } + } + thread.prepend( states ); + } + }, + + // at_end_of_stream/0 + "at_end_of_stream/0": function( thread, point, atom ) { + thread.prepend( [new State( + point.goal.replace( + new Term(",", [new Term("current_input", [new Var("S")]),new Term(",", [ + new Term("stream_property", [new Var("S"),new Term("end_of_stream", [new Var("E")])]), + new Term(",", [new Term("!", []),new Term(";", [new Term("=", [new Var("E"), + new Term("at", [])]),new Term("=", [new Var("E"),new Term("past", [])])])])])]) + ), + point.substitution, + point + )] ); + }, + + // at_end_of_stream/1 + "at_end_of_stream/1": function( thread, point, atom ) { + var stream = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( + new Term(",", [new Term("stream_property", [stream,new Term("end_of_stream", [new Var("E")])]), + new Term(",", [new Term("!", []),new Term(";", [new Term("=", [new Var("E"),new Term("at", [])]), + new Term("=", [new Var("E"),new Term("past", [])])])])]) + ), + point.substitution, + point + )] ); + }, + + // set_stream_position/2 + "set_stream_position/2": function( thread, point, atom ) { + var stream = atom.args[0], position = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( position ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( !pl.type.is_stream_position( position ) ) { + thread.throw_error( pl.error.domain( "stream_position", position, atom.indicator ) ); + } else if( stream2.reposition === false ) { + thread.throw_error( pl.error.permission( "reposition", "stream", stream, atom.indicator ) ); + } else { + if( pl.type.is_integer( position ) ) + stream2.position = position.value; + else + stream2.position = position.id; + thread.success( point ); + } + }, + + + + // CHARACTER INPUT OUTPUT + + // get_char/1 + "get_char/1": function( thread, point, atom ) { + var char = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("get_char", [new Var("S"),char])]) ), + point.substitution, + point + )] ); + }, + + // get_char/2 + "get_char/2": function( thread, point, atom ) { + var stream = atom.args[0], char = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( char ) && !pl.type.is_character( char ) ) { + thread.throw_error( pl.error.type( "in_character", char, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "input", "binary_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + var stream_char; + if( stream2.position === "end_of_stream" ) { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream_char = stream2.stream.get( 1, stream2.position ); + if( stream_char === null ) { + thread.throw_error( pl.error.representation( "character", atom.indicator ) ); + return; + } + stream2.position++; + } + thread.prepend( [new State( + point.goal.replace( new Term( "=", [new Term(stream_char,[]), char] ) ), + point.substitution, + point + )] ); + } + }, + + // get_code/1 + "get_code/1": function( thread, point, atom ) { + var code = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("get_code", [new Var("S"),code])]) ), + point.substitution, + point + )] ); + }, + + // get_code/2 + "get_code/2": function( thread, point, atom ) { + var stream = atom.args[0], code = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( code ) && !pl.type.is_integer( code ) ) { + thread.throw_error( pl.error.type( "integer", char, atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "input", "binary_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + var stream_code; + if( stream2.position === "end_of_stream" ) { + stream_code = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_code = stream2.stream.get( 1, stream2.position ); + if( stream_code === null ) { + thread.throw_error( pl.error.representation( "character", atom.indicator ) ); + return; + } + stream_code = codePointAt( stream_code, 0 ); + stream2.position++; + } + thread.prepend( [new State( + point.goal.replace( new Term( "=", [new Num(stream_code, false), code] ) ), + point.substitution, + point + )] ); + } + }, + + // peek_char/1 + "peek_char/1": function( thread, point, atom ) { + var char = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("peek_char", [new Var("S"),char])]) ), + point.substitution, + point + )] ); + }, + + // peek_char/2 + "peek_char/2": function( thread, point, atom ) { + var stream = atom.args[0], char = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( char ) && !pl.type.is_character( char ) ) { + thread.throw_error( pl.error.type( "in_character", char, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "input", "binary_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + var stream_char; + if( stream2.position === "end_of_stream" ) { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream_char = stream2.stream.get( 1, stream2.position ); + if( stream_char === null ) { + thread.throw_error( pl.error.representation( "character", atom.indicator ) ); + return; + } + } + thread.prepend( [new State( + point.goal.replace( new Term( "=", [new Term(stream_char,[]), char] ) ), + point.substitution, + point + )] ); + } + }, + + // peek_code/1 + "peek_code/1": function( thread, point, atom ) { + var code = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("peek_code", [new Var("S"),code])]) ), + point.substitution, + point + )] ); + }, + + // peek_code/2 + "peek_code/2": function( thread, point, atom ) { + var stream = atom.args[0], code = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( code ) && !pl.type.is_integer( code ) ) { + thread.throw_error( pl.error.type( "integer", char, atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "input", "binary_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + var stream_code; + if( stream2.position === "end_of_stream" ) { + stream_code = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_code = stream2.stream.get( 1, stream2.position ); + if( stream_code === null ) { + thread.throw_error( pl.error.representation( "character", atom.indicator ) ); + return; + } + stream_code = codePointAt( stream_code, 0 ); + } + thread.prepend( [new State( + point.goal.replace( new Term( "=", [new Num(stream_code, false), code] ) ), + point.substitution, + point + )] ); + } + }, + + // put_char/1 + "put_char/1": function( thread, point, atom ) { + var char = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("put_char", [new Var("S"),char])]) ), + point.substitution, + point + )] ); + }, + + // put_char/2 + "put_char/2": function( thread, point, atom ) { + var stream = atom.args[0], char = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( char ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_character( char ) ) { + thread.throw_error( pl.error.type( "character", char, atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.input ) { + thread.throw_error( pl.error.permission( "output", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "output", "binary_stream", stream, atom.indicator ) ); + } else { + if( stream2.stream.put( char.id, stream2.position ) ) { + if(typeof stream2.position === "number") + stream2.position++; + thread.success( point ); + } + } + }, + + // put_code/1 + "put_code/1": function( thread, point, atom ) { + var code = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("put_code", [new Var("S"),code])]) ), + point.substitution, + point + )] ); + }, + + // put_code/2 + "put_code/2": function( thread, point, atom ) { + var stream = atom.args[0], code = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( code ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_integer( code ) ) { + thread.throw_error( pl.error.type( "integer", code, atom.indicator ) ); + } else if( !pl.type.is_character_code( code ) ) { + thread.throw_error( pl.error.representation( "character_code", atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.input ) { + thread.throw_error( pl.error.permission( "output", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "output", "binary_stream", stream, atom.indicator ) ); + } else { + if( stream2.stream.put_char( fromCodePoint( code.value ), stream2.position ) ) { + if(typeof stream2.position === "number") + stream2.position++; + thread.success( point ); + } + } + }, + + // nl/0 + "nl/0": function( thread, point, atom ) { + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("put_char", [new Var("S"), new Term("\n", [])])]) ), + point.substitution, + point + )] ); + }, + + // nl/1 + "nl/1": function( thread, point, atom ) { + var stream = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term("put_char", [stream, new Term("\n", [])]) ), + point.substitution, + point + )] ); + }, + + + + // BYTE INPUT/OUTPUT + + // get_byte/1 + "get_byte/1": function( thread, point, atom ) { + var byte = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("get_byte", [new Var("S"),byte])]) ), + point.substitution, + point + )] ); + }, + + // get_byte/2 + "get_byte/2": function( thread, point, atom ) { + var stream = atom.args[0], byte = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( byte ) && !pl.type.is_byte( byte ) ) { + thread.throw_error( pl.error.type( "in_byte", char, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "text" ) { + thread.throw_error( pl.error.permission( "input", "text_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + var stream_byte; + if( stream2.position === "end_of_stream" ) { + stream_byte = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream_byte = stream2.stream.get_byte( stream2.position ); + if( stream_byte === null ) { + thread.throw_error( pl.error.representation( "byte", atom.indicator ) ); + return; + } + stream2.position++; + } + thread.prepend( [new State( + point.goal.replace( new Term( "=", [new Num(stream_byte,false), byte] ) ), + point.substitution, + point + )] ); + } + }, + + // peek_byte/1 + "peek_byte/1": function( thread, point, atom ) { + var byte = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("peek_byte", [new Var("S"),byte])]) ), + point.substitution, + point + )] ); + }, + + // peek_byte/2 + "peek_byte/2": function( thread, point, atom ) { + var stream = atom.args[0], byte = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_variable( byte ) && !pl.type.is_byte( byte ) ) { + thread.throw_error( pl.error.type( "in_byte", char, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "text" ) { + thread.throw_error( pl.error.permission( "input", "text_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + var stream_byte; + if( stream2.position === "end_of_stream" ) { + stream_byte = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream_byte = stream2.stream.get_byte( stream2.position ); + if( stream_byte === null ) { + thread.throw_error( pl.error.representation( "byte", atom.indicator ) ); + return; + } + } + thread.prepend( [new State( + point.goal.replace( new Term( "=", [new Num(stream_byte,false), byte] ) ), + point.substitution, + point + )] ); + } + }, + + // put_byte/1 + "put_byte/1": function( thread, point, atom ) { + var byte = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("put_byte", [new Var("S"),byte])]) ), + point.substitution, + point + )] ); + }, + + // put_byte/2 + "put_byte/2": function( thread, point, atom ) { + var stream = atom.args[0], byte = atom.args[1]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( byte ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_byte( byte ) ) { + thread.throw_error( pl.error.type( "byte", byte, atom.indicator ) ); + } else if( !pl.type.is_variable( stream ) && !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.input ) { + thread.throw_error( pl.error.permission( "output", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "text" ) { + thread.throw_error( pl.error.permission( "output", "text_stream", stream, atom.indicator ) ); + } else { + if( stream2.stream.put_byte( byte.value, stream2.position ) ) { + if(typeof stream2.position === "number") + stream2.position++; + thread.success( point ); + } + } + }, + + + + // TERM INPUT/OUTPUT + + // read/1 + "read/1": function( thread, point, atom ) { + var term = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("read_term", [new Var("S"),term,new Term("[]",[])])]) ), + point.substitution, + point + )] ); + }, + + // read/2 + "read/2": function( thread, point, atom ) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend( [new State( + point.goal.replace( new Term("read_term", [stream,term,new Term("[]",[])]) ), + point.substitution, + point + )] ); + }, + + // read_term/2 + "read_term/2": function( thread, point, atom ) { + var term = atom.args[0], options = atom.args[1]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_input", [new Var("S")]),new Term("read_term", [new Var("S"),term,options])]) ), + point.substitution, + point + )] ); + }, + + // read_term/3 + "read_term/3": function( thread, point, atom ) { + var stream = atom.args[0], term = atom.args[1], options = atom.args[2]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( options ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_list( options ) ) { + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.output ) { + thread.throw_error( pl.error.permission( "input", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "input", "binary_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "input", "past_end_of_stream", stream, atom.indicator ) ); + } else { + // Get options + var obj_options = {}; + var pointer = options; + var property; + while( pl.type.is_term(pointer) && pointer.indicator === "./2" ) { + property = pointer.args[0]; + if( pl.type.is_variable( property ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( !pl.type.is_read_option( property ) ) { + thread.throw_error( pl.error.domain( "read_option", property, atom.indicator ) ); + return; + } + obj_options[property.id] = property.args[0]; + pointer = pointer.args[1]; + } + if( pointer.indicator !== "[]/0" ) { + if( pl.type.is_variable( pointer ) ) + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + else + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + return; + } else { + var char, tokenizer, expr; + var text = ""; + var tokens = []; + var last_token = null; + // Get term + while( last_token === null || last_token.name !== "atom" || last_token.value !== "." || + (expr.type === ERROR && pl.flatten_error(new Term("throw",[expr.value])).found === "token_not_found") ) { + char = stream2.stream.get( 1, stream2.position ); + if( char === null ) { + thread.throw_error( pl.error.representation( "character", atom.indicator ) ); + return; + } + if( char === "end_of_file" || char === "past_end_of_file" ) { + if( expr ) + thread.throw_error( pl.error.syntax( tokens[expr.len-1], ". or expression expected", false ) ); + else + thread.throw_error( pl.error.syntax( null, "token not found", true ) ); + return; + } + stream2.position++; + text += char; + tokenizer = new Tokenizer( thread ); + tokenizer.new_text( text ); + tokens = tokenizer.get_tokens(); + last_token = tokens !== null && tokens.length > 0 ? tokens[tokens.length-1] : null; + if( tokens === null ) + continue; + expr = parseExpr(thread, tokens, 0, thread.__get_max_priority(), false); + } + // Succeed analyzing term + if( expr.type === SUCCESS && expr.len === tokens.length-1 && last_token.value === "." ) { + expr = expr.value.rename( thread ); + var eq = new Term( "=", [term, expr] ); + // Variables + if( obj_options.variables ) { + var vars = arrayToList( map( nub( expr.variables() ), function(v) { return new Var(v); } ) ); + eq = new Term( ",", [eq, new Term( "=", [obj_options.variables, vars] )] ) + } + // Variable names + if( obj_options.variable_names ) { + var vars = arrayToList( map( nub( expr.variables() ), function(v) { + var prop; + for( prop in thread.session.renamed_variables ) { + if( thread.session.renamed_variables.hasOwnProperty( prop ) ) { + if( thread.session.renamed_variables[ prop ] === v ) + break; + } + } + return new Term( "=", [new Term( prop, []), new Var(v)] ); + } ) ); + eq = new Term( ",", [eq, new Term( "=", [obj_options.variable_names, vars] )] ) + } + // Singletons + if( obj_options.singletons ) { + var vars = arrayToList( map( new Rule( expr, null ).singleton_variables(), function(v) { + var prop; + for( prop in thread.session.renamed_variables ) { + if( thread.session.renamed_variables.hasOwnProperty( prop ) ) { + if( thread.session.renamed_variables[ prop ] === v ) + break; + } + } + return new Term( "=", [new Term( prop, []), new Var(v)] ); + } ) ); + eq = new Term( ",", [eq, new Term( "=", [obj_options.singletons, vars] )] ) + } + thread.prepend( [new State( point.goal.replace( eq ), point.substitution, point )] ); + // Failed analyzing term + } else { + if( expr.type === SUCCESS ) + thread.throw_error( pl.error.syntax( tokens[expr.len], "unexpected token", false ) ); + else + thread.throw_error( expr.value ); + } + } + } + }, + + // write/1 + "write/1": function( thread, point, atom ) { + var term = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("write", [new Var("S"),term])]) ), + point.substitution, + point + )] ); + }, + + // write/2 + "write/2": function( thread, point, atom ) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend( [new State( + point.goal.replace( new Term("write_term", [stream, term, + new Term(".", [new Term("quoted", [new Term("false", [])]), + new Term(".", [new Term("ignore_ops", [new Term("false")]), + new Term(".", [new Term("numbervars", [new Term("true")]), new Term("[]",[])])])])]) ), + point.substitution, + point + )] ); + }, + + // writeq/1 + "writeq/1": function( thread, point, atom ) { + var term = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("writeq", [new Var("S"),term])]) ), + point.substitution, + point + )] ); + }, + + // writeq/2 + "writeq/2": function( thread, point, atom ) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend( [new State( + point.goal.replace( new Term("write_term", [stream, term, + new Term(".", [new Term("quoted", [new Term("true", [])]), + new Term(".", [new Term("ignore_ops", [new Term("false")]), + new Term(".", [new Term("numbervars", [new Term("true")]), new Term("[]",[])])])])]) ), + point.substitution, + point + )] ); + }, + + // write_canonical/1 + "write_canonical/1": function( thread, point, atom ) { + var term = atom.args[0]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("write_canonical", [new Var("S"),term])]) ), + point.substitution, + point + )] ); + }, + + // write_canonical/2 + "write_canonical/2": function( thread, point, atom ) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend( [new State( + point.goal.replace( new Term("write_term", [stream, term, + new Term(".", [new Term("quoted", [new Term("true", [])]), + new Term(".", [new Term("ignore_ops", [new Term("true")]), + new Term(".", [new Term("numbervars", [new Term("false")]), new Term("[]",[])])])])]) ), + point.substitution, + point + )] ); + }, + + // write_term/2 + "write_term/2": function( thread, point, atom ) { + var term = atom.args[0], options = atom.args[1]; + thread.prepend( [new State( + point.goal.replace( new Term(",", [new Term("current_output", [new Var("S")]),new Term("write_term", [new Var("S"),term,options])]) ), + point.substitution, + point + )] ); + }, + + // write_term/3 + "write_term/3": function( thread, point, atom ) { + var stream = atom.args[0], term = atom.args[1], options = atom.args[2]; + var stream2 = pl.type.is_stream( stream ) ? stream : thread.get_stream_by_alias( stream.id ); + if( pl.type.is_variable( stream ) || pl.type.is_variable( options ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_list( options ) ) { + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + } else if( !pl.type.is_stream( stream ) && !pl.type.is_atom( stream ) ) { + thread.throw_error( pl.error.domain( "stream_or_alias", stream, atom.indicator ) ); + } else if( !pl.type.is_stream( stream2 ) || stream2.stream === null ) { + thread.throw_error( pl.error.existence( "stream", stream, atom.indicator ) ); + } else if( stream2.input ) { + thread.throw_error( pl.error.permission( "output", "stream", stream, atom.indicator ) ); + } else if( stream2.type === "binary" ) { + thread.throw_error( pl.error.permission( "output", "binary_stream", stream, atom.indicator ) ); + } else if( stream2.position === "past_end_of_stream" && stream2.eof_action === "error" ) { + thread.throw_error( pl.error.permission( "output", "past_end_of_stream", stream, atom.indicator ) ); + } else { + // Get options + var obj_options = {}; + var pointer = options; + var property; + while( pl.type.is_term(pointer) && pointer.indicator === "./2" ) { + property = pointer.args[0]; + if( pl.type.is_variable( property ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + return; + } else if( !pl.type.is_write_option( property ) ) { + thread.throw_error( pl.error.domain( "write_option", property, atom.indicator ) ); + return; + } + obj_options[property.id] = property.args[0].id === "true"; + pointer = pointer.args[1]; + } + if( pointer.indicator !== "[]/0" ) { + if( pl.type.is_variable( pointer ) ) + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + else + thread.throw_error( pl.error.type( "list", options, atom.indicator ) ); + return; + } else { + obj_options.session = thread.session; + var text = term.toString( obj_options ); + stream2.stream.put( text, stream2.position ); + if( typeof stream2.position === "number" ) + stream2.position += text.length; + thread.success( point ); + } + } + }, + + + + // IMPLEMENTATION DEFINED HOOKS + + // halt/0 + "halt/0": function( thread, point, _ ) { + thread.points = []; + }, + + // halt/1 + "halt/1": function( thread, point, atom ) { + var int = atom.args[0]; + if( pl.type.is_variable( int ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_integer( int ) ) { + thread.throw_error( pl.error.type( "integer", int, atom.indicator ) ); + } else { + thread.points = []; + } + }, + + // current_prolog_flag/2 + "current_prolog_flag/2": function( thread, point, atom ) { + var flag = atom.args[0], value = atom.args[1]; + if( !pl.type.is_variable( flag ) && !pl.type.is_atom( flag ) ) { + thread.throw_error( pl.error.type( "atom", flag, atom.indicator ) ); + } else if( !pl.type.is_variable( flag ) && !pl.type.is_flag( flag ) ) { + thread.throw_error( pl.error.domain( "prolog_flag", flag, atom.indicator ) ); + } else { + var states = []; + for( var name in pl.flag ) { + if(!pl.flag.hasOwnProperty(name)) continue; + var goal = new Term( ",", [new Term( "=", [new Term( name ), flag] ), new Term( "=", [thread.get_flag(name), value] )] ); + states.push( new State( point.goal.replace( goal ), point.substitution, point ) ); + } + thread.prepend( states ); + } + }, + + // set_prolog_flag/2 + "set_prolog_flag/2": function( thread, point, atom ) { + var flag = atom.args[0], value = atom.args[1]; + if( pl.type.is_variable( flag ) || pl.type.is_variable( value ) ) { + thread.throw_error( pl.error.instantiation( atom.indicator ) ); + } else if( !pl.type.is_atom( flag ) ) { + thread.throw_error( pl.error.type( "atom", flag, atom.indicator ) ); + } else if( !pl.type.is_flag( flag ) ) { + thread.throw_error( pl.error.domain( "prolog_flag", flag, atom.indicator ) ); + } else if( !pl.type.is_value_flag( flag, value ) ) { + thread.throw_error( pl.error.domain( "flag_value", new Term( "+", [flag, value] ), atom.indicator ) ); + } else if( !pl.type.is_modifiable_flag( flag ) ) { + thread.throw_error( pl.error.permission( "modify", "flag", flag ) ); + } else { + thread.session.flag[flag.id] = value; + thread.success( point ); + } + } + + }, + + // Flags + flag: { + + // Bounded numbers + bounded: { + allowed: [new Term( "true" ), new Term( "false" )], + value: new Term( "true" ), + changeable: false + }, + + // Maximum integer + max_integer: { + allowed: [new Num( Number.MAX_SAFE_INTEGER )], + value: new Num( Number.MAX_SAFE_INTEGER ), + changeable: false + }, + + // Minimum integer + min_integer: { + allowed: [new Num( Number.MIN_SAFE_INTEGER )], + value: new Num( Number.MIN_SAFE_INTEGER ), + changeable: false + }, + + // Rounding function + integer_rounding_function: { + allowed: [new Term( "down" ), new Term( "toward_zero" )], + value: new Term( "toward_zero" ), + changeable: false + }, + + // Character conversion + char_conversion : { + allowed: [new Term( "on" ), new Term( "off" )], + value: new Term( "on" ), + changeable: true + }, + + // Debugger + debug: { + allowed: [new Term( "on" ), new Term( "off" )], + value: new Term( "off" ), + changeable: true + }, + + // Maximum arity of predicates + max_arity: { + allowed: [new Term( "unbounded" )], + value: new Term( "unbounded" ), + changeable: false + }, + + // Unkwnow predicates behavior + unknown: { + allowed: [new Term( "error" ), new Term( "fail" ), new Term( "warning" )], + value: new Term( "error" ), + changeable: true + }, + + // Double quotes behavior + double_quotes: { + allowed: [new Term( "chars" ), new Term( "codes" ), new Term( "atom" )], + value: new Term( "codes" ), + changeable: true + }, + + // Occurs check behavior + occurs_check: { + allowed: [new Term( "false" ), new Term( "true" )], + value: new Term( "false" ), + changeable: true + }, + + // Dialect + dialect: { + allowed: [new Term( "tau" )], + value: new Term( "tau" ), + changeable: false + }, + + // Version + version_data: { + allowed: [new Term( "tau", [new Num(version.major,false), new Num(version.minor,false), new Num(version.patch,false), new Term(version.status)] )], + value: new Term( "tau", [new Num(version.major,false), new Num(version.minor,false), new Num(version.patch,false), new Term(version.status)] ), + changeable: false + }, + + // NodeJS + nodejs: { + allowed: [new Term( "yes" ), new Term( "no" )], + value: new Term( true && module.exports ? "yes" : "no" ), + changeable: false + } + + }, + + // Unify + unify: function( s, t, occurs_check ) { + occurs_check = occurs_check === undefined ? false : occurs_check; + var G = [{left: s, right: t}], links = {}; + while( G.length !== 0 ) { + var eq = G.pop(); + s = eq.left; + t = eq.right; + if( pl.type.is_term(s) && pl.type.is_term(t) ) { + if( s.indicator !== t.indicator ) + return null; + for( var i = 0; i < s.args.length; i++ ) + G.push( {left: s.args[i], right: t.args[i]} ); + } else if( pl.type.is_number(s) && pl.type.is_number(t) ) { + if( s.value !== t.value || s.is_float !== t.is_float ) + return null; + } else if( pl.type.is_variable(s) ) { + // X = X + if( pl.type.is_variable(t) && s.id === t.id ) + continue; + // Occurs check + if( occurs_check === true && t.variables().indexOf( s.id ) !== -1 ) + return null; + if( s.id !== "_" ) { + var subs = new Substitution(); + subs.add( s.id, t ); + for( var i = 0; i < G.length; i++ ) { + G[i].left = G[i].left.apply( subs ); + G[i].right = G[i].right.apply( subs ); + } + for( var i in links ) + links[i] = links[i].apply( subs ); + links[s.id] = t; + } + } else if( pl.type.is_variable(t) ) { + G.push( {left: t, right: s} ); + } else if( s.unify !== undefined ) { + if( !s.unify(t) ) + return null; + } else { + return null; + } + } + return new Substitution( links ); + }, + + + // Compare + compare: function( obj1, obj2 ) { + var type = pl.type.compare( obj1, obj2 ); + return type !== 0 ? type : obj1.compare( obj2 ); + }, + + // Arithmetic comparison + arithmetic_compare: function( thread, obj1, obj2 ) { + var expr1 = obj1.interpret( thread ); + if( !pl.type.is_number( expr1 ) ) { + return expr1; + } else { + var expr2 = obj2.interpret( thread ); + if( !pl.type.is_number( expr2 ) ) { + return expr2; + } else { + return expr1.value < expr2.value ? -1 : (expr1.value > expr2.value ? 1 : 0); + } + } + }, + + // Operate + operate: function( thread, obj ) { + if( pl.type.is_operator( obj ) ) { + var op = pl.type.is_operator( obj ); + var args = [], value; + var type = false; + for( var i = 0; i < obj.args.length; i++ ) { + value = obj.args[i].interpret( thread ); + if( !pl.type.is_number( value ) ) { + return value; + } else if( op.type_args !== null && value.is_float !== op.type_args ) { + return pl.error.type( op.type_args ? "float" : "integer", value, thread.__call_indicator ); + } else { + args.push( value.value ); + } + type = type || value.is_float; + } + args.push( thread ); + value = pl.arithmetic.evaluation[obj.indicator].fn.apply( this, args ); + type = op.type_result === null ? type : op.type_result; + if( pl.type.is_term( value ) ) { + return value; + } else if( value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY ) { + return pl.error.evaluation( "overflow", thread.__call_indicator ); + } else if( type === false && thread.get_flag( "bounded" ).id === "true" && (value > thread.get_flag( "max_integer" ).value || value < thread.get_flag( "min_integer" ).value) ) { + return pl.error.evaluation( "int_overflow", thread.__call_indicator ); + } else { + return new Num( value, type ); + } + } else { + return pl.error.type( "evaluable", obj.indicator, thread.__call_indicator ); + } + }, + + // Errors + error: { + + // Existence error + existence: function( type, object, indicator ) { + if( typeof object === "string" ) + object = str_indicator( object ); + return new Term( "error", [new Term( "existence_error", [new Term( type ), object] ), str_indicator( indicator )] ); + }, + + // Type error + type: function( expected, found, indicator ) { + return new Term( "error", [new Term( "type_error", [new Term( expected ), found] ), str_indicator( indicator )] ); + }, + + // Instantation error + instantiation: function( indicator ) { + return new Term( "error", [new Term( "instantiation_error" ), str_indicator( indicator )] ); + }, + + // Domain error + domain: function( expected, found, indicator ) { + return new Term( "error", [new Term( "domain_error", [new Term( expected ), found]), str_indicator( indicator )] ); + }, + + // Representation error + representation: function( flag, indicator ) { + return new Term( "error", [new Term( "representation_error", [new Term( flag )] ), str_indicator( indicator )] ); + }, + + // Permission error + permission: function( operation, type, found, indicator ) { + return new Term( "error", [new Term( "permission_error", [new Term( operation ), new Term( type ), found] ), str_indicator( indicator )] ); + }, + + // Evaluation error + evaluation: function( error, indicator ) { + return new Term( "error", [new Term( "evaluation_error", [new Term( error )] ), str_indicator( indicator )] ); + }, + + // Syntax error + syntax: function( token, expected, last ) { + token = token || {value: "", line: 0, column: 0, matches: [""], start: 0}; + var position = last && token.matches.length > 0 ? token.start + token.matches[0].length : token.start; + var found = last ? new Term("token_not_found") : new Term("found", [new Term(token.value.toString())]); + var info = new Term( ".", [new Term( "line", [new Num(token.line+1)] ), new Term( ".", [new Term( "column", [new Num(position+1)] ), new Term( ".", [found, new Term( "[]", [] )] )] )] ); + return new Term( "error", [new Term( "syntax_error", [new Term( expected )] ), info] ); + }, + + // Syntax error by predicate + syntax_by_predicate: function( expected, indicator ) { + return new Term( "error", [new Term( "syntax_error", [new Term( expected ) ] ), str_indicator( indicator )] ); + } + + }, + + // Warnings + warning: { + + // Singleton variables + singleton: function( variables, rule, line ) { + var list = new Term( "[]" ); + for( var i = variables.length-1; i >= 0; i-- ) + list = new Term( ".", [new Var(variables[i]), list] ); + return new Term( "warning", [new Term( "singleton_variables", [list, str_indicator(rule)]), new Term(".",[new Term( "line", [ new Num( line, false ) ]), new Term("[]")])] ); + }, + + // Failed goal + failed_goal: function( goal, line ) { + return new Term( "warning", [new Term( "failed_goal", [goal]), new Term(".",[new Term( "line", [ new Num( line, false ) ]), new Term("[]")])] ); + } + + }, + + // Format of renamed variables + format_variable: function( variable ) { + return "_" + variable; + }, + + // Format of computed answers + format_answer: function( answer, thread, options ) { + if( thread instanceof Session ) + thread = thread.thread; + var options = options ? options : {}; + options.session = thread ? thread.session : undefined; + if( pl.type.is_error( answer ) ) { + return "uncaught exception: " + answer.args[0].toString(); + } else if( answer === false ) { + return "false."; + } else if( answer === null ) { + return "limit exceeded ;"; + } else { + var i = 0; + var str = ""; + if( pl.type.is_substitution( answer ) ) { + var dom = answer.domain( true ); + answer = answer.filter( function( id, value ) { + return !pl.type.is_variable( value ) || dom.indexOf( value.id ) !== -1 && id !== value.id; + } ); + } + for( var link in answer.links ) { + if(!answer.links.hasOwnProperty(link)) continue; + i++; + if( str !== "" ) { + str += ", "; + } + str += link.toString( options ) + " = " + answer.links[link].toString( options ); + } + var delimiter = typeof thread === "undefined" || thread.points.length > 0 ? " ;" : "."; + if( i === 0 ) { + return "true" + delimiter; + } else { + return str + delimiter; + } + } + }, + + // Flatten default errors + flatten_error: function( error ) { + if( !pl.type.is_error( error ) ) return null; + error = error.args[0]; + var obj = {}; + obj.type = error.args[0].id; + obj.thrown = obj.type === "syntax_error" ? null : error.args[1].id; + obj.expected = null; + obj.found = null; + obj.representation = null; + obj.existence = null; + obj.existence_type = null; + obj.line = null; + obj.column = null; + obj.permission_operation = null; + obj.permission_type = null; + obj.evaluation_type = null; + if( obj.type === "type_error" || obj.type === "domain_error" ) { + obj.expected = error.args[0].args[0].id; + obj.found = error.args[0].args[1].toString(); + } else if( obj.type === "syntax_error" ) { + if( error.args[1].indicator === "./2" ) { + obj.expected = error.args[0].args[0].id; + obj.found = error.args[1].args[1].args[1].args[0]; + obj.found = obj.found.id === "token_not_found" ? obj.found.id : obj.found.args[0].id; + obj.line = error.args[1].args[0].args[0].value; + obj.column = error.args[1].args[1].args[0].args[0].value; + } else { + obj.thrown = error.args[1].id; + } + } else if( obj.type === "permission_error" ) { + obj.found = error.args[0].args[2].toString(); + obj.permission_operation = error.args[0].args[0].id; + obj.permission_type = error.args[0].args[1].id; + } else if( obj.type === "evaluation_error" ) { + obj.evaluation_type = error.args[0].args[0].id; + } else if( obj.type === "representation_error" ) { + obj.representation = error.args[0].args[0].id; + } else if( obj.type === "existence_error" ) { + obj.existence = error.args[0].args[1].toString(); + obj.existence_type = error.args[0].args[0].id; + } + return obj; + }, + + // Create new session + create: function( limit ) { + return new pl.type.Session( limit ); + } + + }; + + if( true ) { + module.exports = pl; + } else {} + + })(); + + + /***/ }), + /* 8 */ + /***/ (function(module, exports) { + + module.exports = require("fs"); + + /***/ }), + /* 9 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + /* + * readlineSync + * https://github.com/anseki/readline-sync + * + * Copyright (c) 2018 anseki + * Licensed under the MIT license. + */ + + + + var + IS_WIN = process.platform === 'win32', + + ALGORITHM_CIPHER = 'aes-256-cbc', + ALGORITHM_HASH = 'sha256', + DEFAULT_ERR_MSG = 'The current environment doesn\'t support interactive reading from TTY.', + + fs = __webpack_require__(8), + TTY = process.binding('tty_wrap').TTY, + childProc = __webpack_require__(10), + pathUtil = __webpack_require__(11), + + defaultOptions = { + /* eslint-disable key-spacing */ + prompt: '> ', + hideEchoBack: false, + mask: '*', + limit: [], + limitMessage: 'Input another, please.$<( [)limit(])>', + defaultInput: '', + trueValue: [], + falseValue: [], + caseSensitive: false, + keepWhitespace: false, + encoding: 'utf8', + bufferSize: 1024, + print: void 0, + history: true, + cd: false, + phContent: void 0, + preCheck: void 0 + /* eslint-enable key-spacing */ + }, + + fdR = 'none', fdW, ttyR, isRawMode = false, + extHostPath, extHostArgs, tempdir, salt = 0, + lastInput = '', inputHistory = [], rawInput, + _DBG_useExt = false, _DBG_checkOptions = false, _DBG_checkMethod = false; + + function getHostArgs(options) { + // Send any text to crazy Windows shell safely. + function encodeArg(arg) { + return arg.replace(/[^\w\u0080-\uFFFF]/g, function(chr) { + return '#' + chr.charCodeAt(0) + ';'; + }); + } + + return extHostArgs.concat((function(conf) { + var args = []; + Object.keys(conf).forEach(function(optionName) { + if (conf[optionName] === 'boolean') { + if (options[optionName]) { args.push('--' + optionName); } + } else if (conf[optionName] === 'string') { + if (options[optionName]) { + args.push('--' + optionName, encodeArg(options[optionName])); + } + } + }); + return args; + })({ + /* eslint-disable key-spacing */ + display: 'string', + displayOnly: 'boolean', + keyIn: 'boolean', + hideEchoBack: 'boolean', + mask: 'string', + limit: 'string', + caseSensitive: 'boolean' + /* eslint-enable key-spacing */ + })); + } + + // piping via files (for Node.js v0.10-) + function _execFileSync(options, execOptions) { + + function getTempfile(name) { + var filepath, suffix = '', fd; + tempdir = tempdir || __webpack_require__(12).tmpdir(); + + while (true) { + filepath = pathUtil.join(tempdir, name + suffix); + try { + fd = fs.openSync(filepath, 'wx'); + } catch (e) { + if (e.code === 'EEXIST') { + suffix++; + continue; + } else { + throw e; + } + } + fs.closeSync(fd); + break; + } + return filepath; + } + + var hostArgs, shellPath, shellArgs, res = {}, exitCode, extMessage, + pathStdout = getTempfile('readline-sync.stdout'), + pathStderr = getTempfile('readline-sync.stderr'), + pathExit = getTempfile('readline-sync.exit'), + pathDone = getTempfile('readline-sync.done'), + crypto = __webpack_require__(13), shasum, decipher, password; + + shasum = crypto.createHash(ALGORITHM_HASH); + shasum.update('' + process.pid + (salt++) + Math.random()); + password = shasum.digest('hex'); + decipher = crypto.createDecipher(ALGORITHM_CIPHER, password); + + hostArgs = getHostArgs(options); + if (IS_WIN) { + shellPath = process.env.ComSpec || 'cmd.exe'; + process.env.Q = '"'; // The quote (") that isn't escaped. + // `()` for ignore space by echo + shellArgs = ['/V:ON', '/S', '/C', + '(%Q%' + shellPath + '%Q% /V:ON /S /C %Q%' + /* ESLint bug? */ // eslint-disable-line no-path-concat + '%Q%' + extHostPath + '%Q%' + + hostArgs.map(function(arg) { return ' %Q%' + arg + '%Q%'; }).join('') + + ' & (echo !ERRORLEVEL!)>%Q%' + pathExit + '%Q%%Q%) 2>%Q%' + pathStderr + '%Q%' + + ' |%Q%' + process.execPath + '%Q% %Q%' + __dirname + '\\encrypt.js%Q%' + + ' %Q%' + ALGORITHM_CIPHER + '%Q% %Q%' + password + '%Q%' + + ' >%Q%' + pathStdout + '%Q%' + + ' & (echo 1)>%Q%' + pathDone + '%Q%']; + } else { + shellPath = '/bin/sh'; + shellArgs = ['-c', + // Use `()`, not `{}` for `-c` (text param) + '("' + extHostPath + '"' + /* ESLint bug? */ // eslint-disable-line no-path-concat + hostArgs.map(function(arg) { return " '" + arg.replace(/'/g, "'\\''") + "'"; }).join('') + + '; echo $?>"' + pathExit + '") 2>"' + pathStderr + '"' + + ' |"' + process.execPath + '" "' + __dirname + '/encrypt.js"' + + ' "' + ALGORITHM_CIPHER + '" "' + password + '"' + + ' >"' + pathStdout + '"' + + '; echo 1 >"' + pathDone + '"']; + } + if (_DBG_checkMethod) { _DBG_checkMethod('_execFileSync', hostArgs); } + try { + childProc.spawn(shellPath, shellArgs, execOptions); + } catch (e) { + res.error = new Error(e.message); + res.error.method = '_execFileSync - spawn'; + res.error.program = shellPath; + res.error.args = shellArgs; + } + + while (fs.readFileSync(pathDone, {encoding: options.encoding}).trim() !== '1') {} // eslint-disable-line no-empty + if ((exitCode = + fs.readFileSync(pathExit, {encoding: options.encoding}).trim()) === '0') { + res.input = + decipher.update(fs.readFileSync(pathStdout, {encoding: 'binary'}), + 'hex', options.encoding) + + decipher.final(options.encoding); + } else { + extMessage = fs.readFileSync(pathStderr, {encoding: options.encoding}).trim(); + res.error = new Error(DEFAULT_ERR_MSG + (extMessage ? '\n' + extMessage : '')); + res.error.method = '_execFileSync'; + res.error.program = shellPath; + res.error.args = shellArgs; + res.error.extMessage = extMessage; + res.error.exitCode = +exitCode; + } + + fs.unlinkSync(pathStdout); + fs.unlinkSync(pathStderr); + fs.unlinkSync(pathExit); + fs.unlinkSync(pathDone); + + return res; + } + + function readlineExt(options) { + var hostArgs, res = {}, extMessage, + execOptions = {env: process.env, encoding: options.encoding}; + + if (!extHostPath) { + if (IS_WIN) { + if (process.env.PSModulePath) { // Windows PowerShell + extHostPath = 'powershell.exe'; + extHostArgs = ['-ExecutionPolicy', 'Bypass', '-File', __dirname + '\\read.ps1']; // eslint-disable-line no-path-concat + } else { // Windows Script Host + extHostPath = 'cscript.exe'; + extHostArgs = ['//nologo', __dirname + '\\read.cs.js']; // eslint-disable-line no-path-concat + } + } else { + extHostPath = '/bin/sh'; + extHostArgs = [__dirname + '/read.sh']; // eslint-disable-line no-path-concat + } + } + if (IS_WIN && !process.env.PSModulePath) { // Windows Script Host + // ScriptPW (Win XP and Server2003) needs TTY stream as STDIN. + // In this case, If STDIN isn't TTY, an error is thrown. + execOptions.stdio = [process.stdin]; + } + + if (childProc.execFileSync) { + hostArgs = getHostArgs(options); + if (_DBG_checkMethod) { _DBG_checkMethod('execFileSync', hostArgs); } + try { + res.input = childProc.execFileSync(extHostPath, hostArgs, execOptions); + } catch (e) { // non-zero exit code + extMessage = e.stderr ? (e.stderr + '').trim() : ''; + res.error = new Error(DEFAULT_ERR_MSG + (extMessage ? '\n' + extMessage : '')); + res.error.method = 'execFileSync'; + res.error.program = extHostPath; + res.error.args = hostArgs; + res.error.extMessage = extMessage; + res.error.exitCode = e.status; + res.error.code = e.code; + res.error.signal = e.signal; + } + } else { + res = _execFileSync(options, execOptions); + } + if (!res.error) { + res.input = res.input.replace(/^\s*'|'\s*$/g, ''); + options.display = ''; + } + + return res; + } + + /* + display: string + displayOnly: boolean + keyIn: boolean + hideEchoBack: boolean + mask: string + limit: string (pattern) + caseSensitive: boolean + keepWhitespace: boolean + encoding, bufferSize, print + */ + function _readlineSync(options) { + var input = '', displaySave = options.display, + silent = !options.display && + options.keyIn && options.hideEchoBack && !options.mask; + + function tryExt() { + var res = readlineExt(options); + if (res.error) { throw res.error; } + return res.input; + } + + if (_DBG_checkOptions) { _DBG_checkOptions(options); } + + (function() { // open TTY + var fsB, constants, verNum; + + function getFsB() { + if (!fsB) { + fsB = process.binding('fs'); // For raw device path + constants = process.binding('constants'); + } + return fsB; + } + + if (typeof fdR !== 'string') { return; } + fdR = null; + + if (IS_WIN) { + // iojs-v2.3.2+ input stream can't read first line. (#18) + // ** Don't get process.stdin before check! ** + // Fixed v5.1.0 + // Fixed v4.2.4 + // It regressed again in v5.6.0, it is fixed in v6.2.0. + verNum = (function(ver) { // getVerNum + var nums = ver.replace(/^\D+/, '').split('.'); + var verNum = 0; + if ((nums[0] = +nums[0])) { verNum += nums[0] * 10000; } + if ((nums[1] = +nums[1])) { verNum += nums[1] * 100; } + if ((nums[2] = +nums[2])) { verNum += nums[2]; } + return verNum; + })(process.version); + if (!(verNum >= 20302 && verNum < 40204 || verNum >= 50000 && verNum < 50100 || verNum >= 50600 && verNum < 60200) && + process.stdin.isTTY) { + process.stdin.pause(); + fdR = process.stdin.fd; + ttyR = process.stdin._handle; + } else { + try { + // The stream by fs.openSync('\\\\.\\CON', 'r') can't switch to raw mode. + // 'CONIN$' might fail on XP, 2000, 7 (x86). + fdR = getFsB().open('CONIN$', constants.O_RDWR, parseInt('0666', 8)); + ttyR = new TTY(fdR, true); + } catch (e) { /* ignore */ } + } + + if (process.stdout.isTTY) { + fdW = process.stdout.fd; + } else { + try { + fdW = fs.openSync('\\\\.\\CON', 'w'); + } catch (e) { /* ignore */ } + if (typeof fdW !== 'number') { // Retry + try { + fdW = getFsB().open('CONOUT$', constants.O_RDWR, parseInt('0666', 8)); + } catch (e) { /* ignore */ } + } + } + + } else { + if (process.stdin.isTTY) { + process.stdin.pause(); + try { + fdR = fs.openSync('/dev/tty', 'r'); // device file, not process.stdin + ttyR = process.stdin._handle; + } catch (e) { /* ignore */ } + } else { + // Node.js v0.12 read() fails. + try { + fdR = fs.openSync('/dev/tty', 'r'); + ttyR = new TTY(fdR, false); + } catch (e) { /* ignore */ } + } + + if (process.stdout.isTTY) { + fdW = process.stdout.fd; + } else { + try { + fdW = fs.openSync('/dev/tty', 'w'); + } catch (e) { /* ignore */ } + } + } + })(); + + (function() { // try read + var atEol, limit, + isCooked = !options.hideEchoBack && !options.keyIn, + buffer, reqSize, readSize, chunk, line; + rawInput = ''; + + // Node.js v0.10- returns an error if same mode is set. + function setRawMode(mode) { + if (mode === isRawMode) { return true; } + if (ttyR.setRawMode(mode) !== 0) { return false; } + isRawMode = mode; + return true; + } + + if (_DBG_useExt || !ttyR || + typeof fdW !== 'number' && (options.display || !isCooked)) { + input = tryExt(); + return; + } + + if (options.display) { + fs.writeSync(fdW, options.display); + options.display = ''; + } + if (options.displayOnly) { return; } + + if (!setRawMode(!isCooked)) { + input = tryExt(); + return; + } + + reqSize = options.keyIn ? 1 : options.bufferSize; + // Check `allocUnsafe` to make sure of the new API. + buffer = Buffer.allocUnsafe && Buffer.alloc ? Buffer.alloc(reqSize) : new Buffer(reqSize); + + if (options.keyIn && options.limit) { + limit = new RegExp('[^' + options.limit + ']', + 'g' + (options.caseSensitive ? '' : 'i')); + } + + while (true) { + readSize = 0; + try { + readSize = fs.readSync(fdR, buffer, 0, reqSize); + } catch (e) { + if (e.code !== 'EOF') { + setRawMode(false); + input += tryExt(); + return; + } + } + if (readSize > 0) { + chunk = buffer.toString(options.encoding, 0, readSize); + rawInput += chunk; + } else { + chunk = '\n'; + rawInput += String.fromCharCode(0); + } + + if (chunk && typeof (line = (chunk.match(/^(.*?)[\r\n]/) || [])[1]) === 'string') { + chunk = line; + atEol = true; + } + + // other ctrl-chars + // eslint-disable-next-line no-control-regex + if (chunk) { chunk = chunk.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ''); } + if (chunk && limit) { chunk = chunk.replace(limit, ''); } + + if (chunk) { + if (!isCooked) { + if (!options.hideEchoBack) { + fs.writeSync(fdW, chunk); + } else if (options.mask) { + fs.writeSync(fdW, (new Array(chunk.length + 1)).join(options.mask)); + } + } + input += chunk; + } + + if (!options.keyIn && atEol || + options.keyIn && input.length >= reqSize) { break; } + } + + if (!isCooked && !silent) { fs.writeSync(fdW, '\n'); } + setRawMode(false); + })(); + + if (options.print && !silent) { + options.print(displaySave + (options.displayOnly ? '' : + (options.hideEchoBack ? (new Array(input.length + 1)).join(options.mask) + : input) + '\n'), // must at least write '\n' + options.encoding); + } + + return options.displayOnly ? '' : + (lastInput = options.keepWhitespace || options.keyIn ? input : input.trim()); + } + + function flattenArray(array, validator) { + var flatArray = []; + function _flattenArray(array) { + if (array == null) { + return; + } else if (Array.isArray(array)) { + array.forEach(_flattenArray); + } else if (!validator || validator(array)) { + flatArray.push(array); + } + } + _flattenArray(array); + return flatArray; + } + + function escapePattern(pattern) { + return pattern.replace(/[\x00-\x7f]/g, // eslint-disable-line no-control-regex + function(s) { return '\\x' + ('00' + s.charCodeAt().toString(16)).substr(-2); }); + } + + // margeOptions(options1, options2 ... ) + // margeOptions(true, options1, options2 ... ) + // arg1=true : Start from defaultOptions and pick elements of that. + function margeOptions() { + var optionsList = Array.prototype.slice.call(arguments), + optionNames, fromDefault; + + if (optionsList.length && typeof optionsList[0] === 'boolean') { + fromDefault = optionsList.shift(); + if (fromDefault) { + optionNames = Object.keys(defaultOptions); + optionsList.unshift(defaultOptions); + } + } + + return optionsList.reduce(function(options, optionsPart) { + if (optionsPart == null) { return options; } + + // ======== DEPRECATED ======== + if (optionsPart.hasOwnProperty('noEchoBack') && + !optionsPart.hasOwnProperty('hideEchoBack')) { + optionsPart.hideEchoBack = optionsPart.noEchoBack; + delete optionsPart.noEchoBack; + } + if (optionsPart.hasOwnProperty('noTrim') && + !optionsPart.hasOwnProperty('keepWhitespace')) { + optionsPart.keepWhitespace = optionsPart.noTrim; + delete optionsPart.noTrim; + } + // ======== /DEPRECATED ======== + + if (!fromDefault) { optionNames = Object.keys(optionsPart); } + optionNames.forEach(function(optionName) { + var value; + if (!optionsPart.hasOwnProperty(optionName)) { return; } + value = optionsPart[optionName]; + switch (optionName) { + // _readlineSync <- * * -> defaultOptions + // ================ string + case 'mask': // * * + case 'limitMessage': // * + case 'defaultInput': // * + case 'encoding': // * * + value = value != null ? value + '' : ''; + if (value && optionName !== 'limitMessage') { value = value.replace(/[\r\n]/g, ''); } + options[optionName] = value; + break; + // ================ number(int) + case 'bufferSize': // * * + if (!isNaN(value = parseInt(value, 10)) && typeof value === 'number') { + options[optionName] = value; // limited updating (number is needed) + } + break; + // ================ boolean + case 'displayOnly': // * + case 'keyIn': // * + case 'hideEchoBack': // * * + case 'caseSensitive': // * * + case 'keepWhitespace': // * * + case 'history': // * + case 'cd': // * + options[optionName] = !!value; + break; + // ================ array + case 'limit': // * * to string for readlineExt + case 'trueValue': // * + case 'falseValue': // * + options[optionName] = flattenArray(value, function(value) { + var type = typeof value; + return type === 'string' || type === 'number' || + type === 'function' || value instanceof RegExp; + }).map(function(value) { + return typeof value === 'string' ? value.replace(/[\r\n]/g, '') : value; + }); + break; + // ================ function + case 'print': // * * + case 'phContent': // * + case 'preCheck': // * + options[optionName] = typeof value === 'function' ? value : void 0; + break; + // ================ other + case 'prompt': // * + case 'display': // * + options[optionName] = value != null ? value : ''; + break; + // no default + } + }); + return options; + }, {}); + } + + function isMatched(res, comps, caseSensitive) { + return comps.some(function(comp) { + var type = typeof comp; + return type === 'string' ? + (caseSensitive ? res === comp : res.toLowerCase() === comp.toLowerCase()) : + type === 'number' ? parseFloat(res) === comp : + type === 'function' ? comp(res) : + comp instanceof RegExp ? comp.test(res) : false; + }); + } + + function replaceHomePath(path, expand) { + var homePath = pathUtil.normalize( + IS_WIN ? (process.env.HOMEDRIVE || '') + (process.env.HOMEPATH || '') : + process.env.HOME || '').replace(/[\/\\]+$/, ''); + path = pathUtil.normalize(path); + return expand ? path.replace(/^~(?=\/|\\|$)/, homePath) : + path.replace(new RegExp('^' + escapePattern(homePath) + + '(?=\\/|\\\\|$)', IS_WIN ? 'i' : ''), '~'); + } + + function replacePlaceholder(text, generator) { + var PTN_INNER = '(?:\\(([\\s\\S]*?)\\))?(\\w+|.-.)(?:\\(([\\s\\S]*?)\\))?', + rePlaceholder = new RegExp('(\\$)?(\\$<' + PTN_INNER + '>)', 'g'), + rePlaceholderCompat = new RegExp('(\\$)?(\\$\\{' + PTN_INNER + '\\})', 'g'); + + function getPlaceholderText(s, escape, placeholder, pre, param, post) { + var text; + return escape || typeof (text = generator(param)) !== 'string' ? placeholder : + text ? (pre || '') + text + (post || '') : ''; + } + + return text.replace(rePlaceholder, getPlaceholderText) + .replace(rePlaceholderCompat, getPlaceholderText); + } + + function array2charlist(array, caseSensitive, collectSymbols) { + var values, group = [], groupClass = -1, charCode = 0, symbols = '', suppressed; + function addGroup(groups, group) { + if (group.length > 3) { // ellipsis + groups.push(group[0] + '...' + group[group.length - 1]); + suppressed = true; + } else if (group.length) { + groups = groups.concat(group); + } + return groups; + } + + values = array.reduce( + function(chars, value) { return chars.concat((value + '').split('')); }, []) + .reduce(function(groups, curChar) { + var curGroupClass, curCharCode; + if (!caseSensitive) { curChar = curChar.toLowerCase(); } + curGroupClass = /^\d$/.test(curChar) ? 1 : + /^[A-Z]$/.test(curChar) ? 2 : /^[a-z]$/.test(curChar) ? 3 : 0; + if (collectSymbols && curGroupClass === 0) { + symbols += curChar; + } else { + curCharCode = curChar.charCodeAt(0); + if (curGroupClass && curGroupClass === groupClass && + curCharCode === charCode + 1) { + group.push(curChar); + } else { + groups = addGroup(groups, group); + group = [curChar]; + groupClass = curGroupClass; + } + charCode = curCharCode; + } + return groups; + }, []); + values = addGroup(values, group); // last group + if (symbols) { values.push(symbols); suppressed = true; } + return {values: values, suppressed: suppressed}; + } + + function joinChunks(chunks, suppressed) { + return chunks.join(chunks.length > 2 ? ', ' : suppressed ? ' / ' : '/'); + } + + function getPhContent(param, options) { + var text, values, resCharlist = {}, arg; + if (options.phContent) { + text = options.phContent(param, options); + } + if (typeof text !== 'string') { + switch (param) { + case 'hideEchoBack': + case 'mask': + case 'defaultInput': + case 'caseSensitive': + case 'keepWhitespace': + case 'encoding': + case 'bufferSize': + case 'history': + case 'cd': + text = !options.hasOwnProperty(param) ? '' : + typeof options[param] === 'boolean' ? (options[param] ? 'on' : 'off') : + options[param] + ''; + break; + // case 'prompt': + // case 'query': + // case 'display': + // text = options.hasOwnProperty('displaySrc') ? options.displaySrc + '' : ''; + // break; + case 'limit': + case 'trueValue': + case 'falseValue': + values = options[options.hasOwnProperty(param + 'Src') ? param + 'Src' : param]; + if (options.keyIn) { // suppress + resCharlist = array2charlist(values, options.caseSensitive); + values = resCharlist.values; + } else { + values = values.filter(function(value) { + var type = typeof value; + return type === 'string' || type === 'number'; + }); + } + text = joinChunks(values, resCharlist.suppressed); + break; + case 'limitCount': + case 'limitCountNotZero': + text = options[options.hasOwnProperty('limitSrc') ? + 'limitSrc' : 'limit'].length; + text = text || param !== 'limitCountNotZero' ? text + '' : ''; + break; + case 'lastInput': + text = lastInput; + break; + case 'cwd': + case 'CWD': + case 'cwdHome': + text = process.cwd(); + if (param === 'CWD') { + text = pathUtil.basename(text); + } else if (param === 'cwdHome') { + text = replaceHomePath(text); + } + break; + case 'date': + case 'time': + case 'localeDate': + case 'localeTime': + text = (new Date())['to' + + param.replace(/^./, function(str) { return str.toUpperCase(); }) + + 'String'](); + break; + default: // with arg + if (typeof (arg = (param.match(/^history_m(\d+)$/) || [])[1]) === 'string') { + text = inputHistory[inputHistory.length - arg] || ''; + } + } + } + return text; + } + + function getPhCharlist(param) { + var matches = /^(.)-(.)$/.exec(param), text = '', from, to, code, step; + if (!matches) { return null; } + from = matches[1].charCodeAt(0); + to = matches[2].charCodeAt(0); + step = from < to ? 1 : -1; + for (code = from; code !== to + step; code += step) { text += String.fromCharCode(code); } + return text; + } + + // cmd "arg" " a r g " "" 'a"r"g' "a""rg" "arg + function parseCl(cl) { + var reToken = new RegExp(/(\s*)(?:("|')(.*?)(?:\2|$)|(\S+))/g), matches, + taken = '', args = [], part; + cl = cl.trim(); + while ((matches = reToken.exec(cl))) { + part = matches[3] || matches[4] || ''; + if (matches[1]) { + args.push(taken); + taken = ''; + } + taken += part; + } + if (taken) { args.push(taken); } + return args; + } + + function toBool(res, options) { + return ( + (options.trueValue.length && + isMatched(res, options.trueValue, options.caseSensitive)) ? true : + (options.falseValue.length && + isMatched(res, options.falseValue, options.caseSensitive)) ? false : res); + } + + function getValidLine(options) { + var res, forceNext, limitMessage, + matches, histInput, args, resCheck; + + function _getPhContent(param) { return getPhContent(param, options); } + function addDisplay(text) { options.display += (/[^\r\n]$/.test(options.display) ? '\n' : '') + text; } + + options.limitSrc = options.limit; + options.displaySrc = options.display; + options.limit = ''; // for readlineExt + options.display = replacePlaceholder(options.display + '', _getPhContent); + + while (true) { + res = _readlineSync(options); + forceNext = false; + limitMessage = ''; + + if (options.defaultInput && !res) { res = options.defaultInput; } + + if (options.history) { + if ((matches = /^\s*\!(?:\!|-1)(:p)?\s*$/.exec(res))) { // `!!` `!-1` +`:p` + histInput = inputHistory[0] || ''; + if (matches[1]) { // only display + forceNext = true; + } else { // replace input + res = histInput; + } + // Show it even if it is empty (NL only). + addDisplay(histInput + '\n'); + if (!forceNext) { // Loop may break + options.displayOnly = true; + _readlineSync(options); + options.displayOnly = false; + } + } else if (res && res !== inputHistory[inputHistory.length - 1]) { + inputHistory = [res]; + } + } + + if (!forceNext && options.cd && res) { + args = parseCl(res); + switch (args[0].toLowerCase()) { + case 'cd': + if (args[1]) { + try { + process.chdir(replaceHomePath(args[1], true)); + } catch (e) { + addDisplay(e + ''); + } + } + forceNext = true; + break; + case 'pwd': + addDisplay(process.cwd()); + forceNext = true; + break; + // no default + } + } + + if (!forceNext && options.preCheck) { + resCheck = options.preCheck(res, options); + res = resCheck.res; + if (resCheck.forceNext) { forceNext = true; } // Don't switch to false. + } + + if (!forceNext) { + if (!options.limitSrc.length || + isMatched(res, options.limitSrc, options.caseSensitive)) { break; } + if (options.limitMessage) { + limitMessage = replacePlaceholder(options.limitMessage, _getPhContent); + } + } + + addDisplay((limitMessage ? limitMessage + '\n' : '') + + replacePlaceholder(options.displaySrc + '', _getPhContent)); + } + return toBool(res, options); + } + + // for dev + exports._DBG_set_useExt = function(val) { _DBG_useExt = val; }; + exports._DBG_set_checkOptions = function(val) { _DBG_checkOptions = val; }; + exports._DBG_set_checkMethod = function(val) { _DBG_checkMethod = val; }; + exports._DBG_clearHistory = function() { lastInput = ''; inputHistory = []; }; + + // ------------------------------------ + + exports.setDefaultOptions = function(options) { + defaultOptions = margeOptions(true, options); + return margeOptions(true); // copy + }; + + exports.question = function(query, options) { + /* eslint-disable key-spacing */ + return getValidLine(margeOptions(margeOptions(true, options), { + display: query + })); + /* eslint-enable key-spacing */ + }; + + exports.prompt = function(options) { + var readOptions = margeOptions(true, options); + readOptions.display = readOptions.prompt; + return getValidLine(readOptions); + }; + + exports.keyIn = function(query, options) { + /* eslint-disable key-spacing */ + var readOptions = margeOptions(margeOptions(true, options), { + display: query, + keyIn: true, + keepWhitespace: true + }); + /* eslint-enable key-spacing */ + + // char list + readOptions.limitSrc = readOptions.limit.filter(function(value) { + var type = typeof value; + return type === 'string' || type === 'number'; + }) + .map(function(text) { return replacePlaceholder(text + '', getPhCharlist); }); + // pattern + readOptions.limit = escapePattern(readOptions.limitSrc.join('')); + + ['trueValue', 'falseValue'].forEach(function(optionName) { + readOptions[optionName] = readOptions[optionName].reduce(function(comps, comp) { + var type = typeof comp; + if (type === 'string' || type === 'number') { + comps = comps.concat((comp + '').split('')); + } else { comps.push(comp); } + return comps; + }, []); + }); + + readOptions.display = replacePlaceholder(readOptions.display + '', + function(param) { return getPhContent(param, readOptions); }); + + return toBool(_readlineSync(readOptions), readOptions); + }; + + // ------------------------------------ + + exports.questionEMail = function(query, options) { + if (query == null) { query = 'Input e-mail address: '; } + /* eslint-disable key-spacing */ + return exports.question(query, margeOptions({ + // -------- default + hideEchoBack: false, + // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address + limit: /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, + limitMessage: 'Input valid e-mail address, please.', + trueValue: null, + falseValue: null + }, options, { + // -------- forced + keepWhitespace: false, + cd: false + })); + /* eslint-enable key-spacing */ + }; + + exports.questionNewPassword = function(query, options) { + /* eslint-disable key-spacing */ + var resCharlist, min, max, + readOptions = margeOptions({ + // -------- default + hideEchoBack: true, + mask: '*', + limitMessage: 'It can include: $\n' + + 'And the length must be: $', + trueValue: null, + falseValue: null, + caseSensitive: true + }, options, { + // -------- forced + history: false, + cd: false, + // limit (by charlist etc.), + phContent: function(param) { + return param === 'charlist' ? resCharlist.text : + param === 'length' ? min + '...' + max : null; + } + }), + // added: charlist, min, max, confirmMessage, unmatchMessage + charlist, confirmMessage, unmatchMessage, + limit, limitMessage, res1, res2; + /* eslint-enable key-spacing */ + options = options || {}; + + charlist = replacePlaceholder( + options.charlist ? options.charlist + '' : '$', getPhCharlist); + if (isNaN(min = parseInt(options.min, 10)) || typeof min !== 'number') { min = 12; } + if (isNaN(max = parseInt(options.max, 10)) || typeof max !== 'number') { max = 24; } + limit = new RegExp('^[' + escapePattern(charlist) + + ']{' + min + ',' + max + '}$'); + resCharlist = array2charlist([charlist], readOptions.caseSensitive, true); + resCharlist.text = joinChunks(resCharlist.values, resCharlist.suppressed); + + confirmMessage = options.confirmMessage != null ? options.confirmMessage : + 'Reinput a same one to confirm it: '; + unmatchMessage = options.unmatchMessage != null ? options.unmatchMessage : + 'It differs from first one.' + + ' Hit only the Enter key if you want to retry from first one.'; + + if (query == null) { query = 'Input new password: '; } + + limitMessage = readOptions.limitMessage; + while (!res2) { + readOptions.limit = limit; + readOptions.limitMessage = limitMessage; + res1 = exports.question(query, readOptions); + + readOptions.limit = [res1, '']; + readOptions.limitMessage = unmatchMessage; + res2 = exports.question(confirmMessage, readOptions); + } + + return res1; + }; + + function _questionNum(query, options, parser) { + var validValue; + function getValidValue(value) { + validValue = parser(value); + return !isNaN(validValue) && typeof validValue === 'number'; + } + /* eslint-disable key-spacing */ + exports.question(query, margeOptions({ + // -------- default + limitMessage: 'Input valid number, please.' + }, options, { + // -------- forced + limit: getValidValue, + cd: false + // trueValue, falseValue, caseSensitive, keepWhitespace don't work. + })); + /* eslint-enable key-spacing */ + return validValue; + } + exports.questionInt = function(query, options) { + return _questionNum(query, options, function(value) { return parseInt(value, 10); }); + }; + exports.questionFloat = function(query, options) { + return _questionNum(query, options, parseFloat); + }; + + exports.questionPath = function(query, options) { + /* eslint-disable key-spacing */ + var validPath, error = '', + readOptions = margeOptions({ + // -------- default + hideEchoBack: false, + limitMessage: '$Input valid path, please.' + + '$<( Min:)min>$<( Max:)max>', + history: true, + cd: true + }, options, { + // -------- forced + keepWhitespace: false, + limit: function(value) { + var exists, stat, res; + value = replaceHomePath(value, true); + error = ''; // for validate + // mkdir -p + function mkdirParents(dirPath) { + dirPath.split(/\/|\\/).reduce(function(parents, dir) { + var path = pathUtil.resolve((parents += dir + pathUtil.sep)); + if (!fs.existsSync(path)) { + fs.mkdirSync(path); + } else if (!fs.statSync(path).isDirectory()) { + throw new Error('Non directory already exists: ' + path); + } + return parents; + }, ''); + } + + try { + exists = fs.existsSync(value); + validPath = exists ? fs.realpathSync(value) : pathUtil.resolve(value); + // options.exists default: true, not-bool: no-check + if (!options.hasOwnProperty('exists') && !exists || + typeof options.exists === 'boolean' && options.exists !== exists) { + error = (exists ? 'Already exists' : 'No such file or directory') + + ': ' + validPath; + return false; + } + if (!exists && options.create) { + if (options.isDirectory) { + mkdirParents(validPath); + } else { + mkdirParents(pathUtil.dirname(validPath)); + fs.closeSync(fs.openSync(validPath, 'w')); // touch + } + validPath = fs.realpathSync(validPath); + } + if (exists && (options.min || options.max || + options.isFile || options.isDirectory)) { + stat = fs.statSync(validPath); + // type check first (directory has zero size) + if (options.isFile && !stat.isFile()) { + error = 'Not file: ' + validPath; + return false; + } else if (options.isDirectory && !stat.isDirectory()) { + error = 'Not directory: ' + validPath; + return false; + } else if (options.min && stat.size < +options.min || + options.max && stat.size > +options.max) { + error = 'Size ' + stat.size + ' is out of range: ' + validPath; + return false; + } + } + if (typeof options.validate === 'function' && + (res = options.validate(validPath)) !== true) { + if (typeof res === 'string') { error = res; } + return false; + } + } catch (e) { + error = e + ''; + return false; + } + return true; + }, + // trueValue, falseValue, caseSensitive don't work. + phContent: function(param) { + return param === 'error' ? error : + param !== 'min' && param !== 'max' ? null : + options.hasOwnProperty(param) ? options[param] + '' : ''; + } + }); + // added: exists, create, min, max, isFile, isDirectory, validate + /* eslint-enable key-spacing */ + options = options || {}; + + if (query == null) { query = 'Input path (you can "cd" and "pwd"): '; } + + exports.question(query, readOptions); + return validPath; + }; + + // props: preCheck, args, hRes, limit + function getClHandler(commandHandler, options) { + var clHandler = {}, hIndex = {}; + if (typeof commandHandler === 'object') { + Object.keys(commandHandler).forEach(function(cmd) { + if (typeof commandHandler[cmd] === 'function') { + hIndex[options.caseSensitive ? cmd : cmd.toLowerCase()] = commandHandler[cmd]; + } + }); + clHandler.preCheck = function(res) { + var cmdKey; + clHandler.args = parseCl(res); + cmdKey = clHandler.args[0] || ''; + if (!options.caseSensitive) { cmdKey = cmdKey.toLowerCase(); } + clHandler.hRes = + cmdKey !== '_' && hIndex.hasOwnProperty(cmdKey) ? + hIndex[cmdKey].apply(res, clHandler.args.slice(1)) : + hIndex.hasOwnProperty('_') ? hIndex._.apply(res, clHandler.args) : null; + return {res: res, forceNext: false}; + }; + if (!hIndex.hasOwnProperty('_')) { + clHandler.limit = function() { // It's called after preCheck. + var cmdKey = clHandler.args[0] || ''; + if (!options.caseSensitive) { cmdKey = cmdKey.toLowerCase(); } + return hIndex.hasOwnProperty(cmdKey); + }; + } + } else { + clHandler.preCheck = function(res) { + clHandler.args = parseCl(res); + clHandler.hRes = typeof commandHandler === 'function' ? + commandHandler.apply(res, clHandler.args) : true; // true for break loop + return {res: res, forceNext: false}; + }; + } + return clHandler; + } + + exports.promptCL = function(commandHandler, options) { + /* eslint-disable key-spacing */ + var readOptions = margeOptions({ + // -------- default + hideEchoBack: false, + limitMessage: 'Requested command is not available.', + caseSensitive: false, + history: true + }, options), + // -------- forced + // trueValue, falseValue, keepWhitespace don't work. + // preCheck, limit (by clHandler) + clHandler = getClHandler(commandHandler, readOptions); + /* eslint-enable key-spacing */ + readOptions.limit = clHandler.limit; + readOptions.preCheck = clHandler.preCheck; + exports.prompt(readOptions); + return clHandler.args; + }; + + exports.promptLoop = function(inputHandler, options) { + /* eslint-disable key-spacing */ + var readOptions = margeOptions({ + // -------- default + hideEchoBack: false, + trueValue: null, + falseValue: null, + caseSensitive: false, + history: true + }, options); + /* eslint-enable key-spacing */ + while (true) { if (inputHandler(exports.prompt(readOptions))) { break; } } + return; + }; + + exports.promptCLLoop = function(commandHandler, options) { + /* eslint-disable key-spacing */ + var readOptions = margeOptions({ + // -------- default + hideEchoBack: false, + limitMessage: 'Requested command is not available.', + caseSensitive: false, + history: true + }, options), + // -------- forced + // trueValue, falseValue, keepWhitespace don't work. + // preCheck, limit (by clHandler) + clHandler = getClHandler(commandHandler, readOptions); + /* eslint-enable key-spacing */ + readOptions.limit = clHandler.limit; + readOptions.preCheck = clHandler.preCheck; + while (true) { + exports.prompt(readOptions); + if (clHandler.hRes) { break; } + } + return; + }; + + exports.promptSimShell = function(options) { + /* eslint-disable key-spacing */ + return exports.prompt(margeOptions({ + // -------- default + hideEchoBack: false, + history: true + }, options, { + // -------- forced + prompt: (function() { + return IS_WIN ? + '$>' : + // 'user@host:cwd$ ' + (process.env.USER || '') + + (process.env.HOSTNAME ? + '@' + process.env.HOSTNAME.replace(/\..*$/, '') : '') + + ':$$ '; + })() + })); + /* eslint-enable key-spacing */ + }; + + function _keyInYN(query, options, limit) { + var res; + if (query == null) { query = 'Are you sure? '; } + if ((!options || options.guide !== false) && (query += '')) { + query = query.replace(/\s*:?\s*$/, '') + ' [y/n]: '; + } + /* eslint-disable key-spacing */ + res = exports.keyIn(query, margeOptions(options, { + // -------- forced + hideEchoBack: false, + limit: limit, + trueValue: 'y', + falseValue: 'n', + caseSensitive: false + // mask doesn't work. + })); + // added: guide + /* eslint-enable key-spacing */ + return typeof res === 'boolean' ? res : ''; + } + exports.keyInYN = function(query, options) { return _keyInYN(query, options); }; + exports.keyInYNStrict = function(query, options) { return _keyInYN(query, options, 'yn'); }; + + exports.keyInPause = function(query, options) { + if (query == null) { query = 'Continue...'; } + if ((!options || options.guide !== false) && (query += '')) { + query = query.replace(/\s+$/, '') + ' (Hit any key)'; + } + /* eslint-disable key-spacing */ + exports.keyIn(query, margeOptions({ + // -------- default + limit: null + }, options, { + // -------- forced + hideEchoBack: true, + mask: '' + })); + // added: guide + /* eslint-enable key-spacing */ + return; + }; + + exports.keyInSelect = function(items, query, options) { + /* eslint-disable key-spacing */ + var readOptions = margeOptions({ + // -------- default + hideEchoBack: false + }, options, { + // -------- forced + trueValue: null, + falseValue: null, + caseSensitive: false, + // limit (by items), + phContent: function(param) { + return param === 'itemsCount' ? items.length + '' : + param === 'firstItem' ? (items[0] + '').trim() : + param === 'lastItem' ? (items[items.length - 1] + '').trim() : null; + } + }), + // added: guide, cancel + keylist = '', key2i = {}, charCode = 49 /* '1' */, display = '\n'; + /* eslint-enable key-spacing */ + if (!Array.isArray(items) || !items.length || items.length > 35) { + throw '`items` must be Array (max length: 35).'; + } + + items.forEach(function(item, i) { + var key = String.fromCharCode(charCode); + keylist += key; + key2i[key] = i; + display += '[' + key + '] ' + (item + '').trim() + '\n'; + charCode = charCode === 57 /* '9' */ ? 97 /* 'a' */ : charCode + 1; + }); + if (!options || options.cancel !== false) { + keylist += '0'; + key2i['0'] = -1; + display += '[0] ' + + (options && options.cancel != null && typeof options.cancel !== 'boolean' ? + (options.cancel + '').trim() : 'CANCEL') + '\n'; + } + readOptions.limit = keylist; + display += '\n'; + + if (query == null) { query = 'Choose one from list: '; } + if ((query += '')) { + if (!options || options.guide !== false) { + query = query.replace(/\s*:?\s*$/, '') + ' [$]: '; + } + display += query; + } + + return key2i[exports.keyIn(display, readOptions).toLowerCase()]; + }; + + exports.getRawInput = function() { return rawInput; }; + + // ======== DEPRECATED ======== + function _setOption(optionName, args) { + var options; + if (args.length) { options = {}; options[optionName] = args[0]; } + return exports.setDefaultOptions(options)[optionName]; + } + exports.setPrint = function() { return _setOption('print', arguments); }; + exports.setPrompt = function() { return _setOption('prompt', arguments); }; + exports.setEncoding = function() { return _setOption('encoding', arguments); }; + exports.setMask = function() { return _setOption('mask', arguments); }; + exports.setBufferSize = function() { return _setOption('bufferSize', arguments); }; + + + /***/ }), + /* 10 */ + /***/ (function(module, exports) { + + module.exports = require("child_process"); + + /***/ }), + /* 11 */ + /***/ (function(module, exports) { + + module.exports = require("path"); + + /***/ }), + /* 12 */ + /***/ (function(module, exports) { + + module.exports = require("os"); + + /***/ }), + /* 13 */ + /***/ (function(module, exports) { + + module.exports = require("crypto"); + + /***/ }), + /* 14 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + /// + + var __importDefault = this && this.__importDefault || function (mod) { + return mod && mod.__esModule ? mod : { + "default": mod + }; + }; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + const core_1 = __webpack_require__(1); + + const get_1 = __importDefault(__webpack_require__(15)); + + const tau_prolog_1 = __importDefault(__webpack_require__(7)); + + const vm_1 = __importDefault(__webpack_require__(67)); // eslint-disable-next-line @typescript-eslint/camelcase + + + const { + is_atom: isAtom, + is_variable: isVariable, + is_instantiated_list: isInstantiatedList + } = tau_prolog_1.default.type; + + function prependGoals(thread, point, goals) { + thread.prepend(goals.map(goal => new tau_prolog_1.default.type.State(point.goal.replace(goal), point.substitution, point))); + } + + const projects = new WeakMap(); + + function getProject(thread) { + const project = projects.get(thread.session); + if (project == null) throw new Error(`Assertion failed: A project should have been registered for the active session`); + return project; + } + + const tauModule = new tau_prolog_1.default.type.Module(`constraints`, { + [`project_workspaces_by_descriptor/3`]: (thread, point, atom) => { + const [descriptorIdent, descriptorRange, workspaceCwd] = atom.args; + + if (!isAtom(descriptorIdent) || !isAtom(descriptorRange)) { + thread.throwError(tau_prolog_1.default.error.instantiation(atom.indicator)); + return; + } + + const ident = core_1.structUtils.parseIdent(descriptorIdent.id); + const descriptor = core_1.structUtils.makeDescriptor(ident, descriptorRange.id); + const project = getProject(thread); + const workspace = project.tryWorkspaceByDescriptor(descriptor); + + if (isVariable(workspaceCwd)) { + if (workspace !== null) { + prependGoals(thread, point, [new tau_prolog_1.default.type.Term(`=`, [workspaceCwd, new tau_prolog_1.default.type.Term(String(workspace.relativeCwd))])]); + } + } + + if (isAtom(workspaceCwd)) { + if (workspace !== null && workspace.relativeCwd === workspaceCwd.id) { + thread.success(point); + } + } + }, + [`workspace_field/3`]: (thread, point, atom) => { + const [workspaceCwd, fieldName, fieldValue] = atom.args; + + if (!isAtom(workspaceCwd) || !isAtom(fieldName)) { + thread.throwError(tau_prolog_1.default.error.instantiation(atom.indicator)); + return; + } + + const project = getProject(thread); + const workspace = project.tryWorkspaceByCwd(workspaceCwd.id); // Workspace not found => this predicate can never match + // We might want to throw here? We can be pretty sure the user did + // something wrong at this point + + if (workspace == null) return; + const value = get_1.default(workspace.manifest.raw, fieldName.id); // Field is not present => this predicate can never match + + if (typeof value === `undefined`) return; + prependGoals(thread, point, [new tau_prolog_1.default.type.Term(`=`, [fieldValue, new tau_prolog_1.default.type.Term(String(value))])]); + }, + [`workspace_field_test/3`]: (thread, point, atom) => { + const [workspaceCwd, fieldName, checkCode] = atom.args; + thread.prepend([new tau_prolog_1.default.type.State(point.goal.replace(new tau_prolog_1.default.type.Term(`workspace_field_test`, [workspaceCwd, fieldName, checkCode, new tau_prolog_1.default.type.Term(`[]`, [])])), point.substitution, point)]); + }, + [`workspace_field_test/4`]: (thread, point, atom) => { + const [workspaceCwd, fieldName, checkCode, checkArgv] = atom.args; + + if (!isAtom(workspaceCwd) || !isAtom(fieldName) || !isAtom(checkCode) || !isInstantiatedList(checkArgv)) { + thread.throwError(tau_prolog_1.default.error.instantiation(atom.indicator)); + return; + } + + const project = getProject(thread); + const workspace = project.tryWorkspaceByCwd(workspaceCwd.id); // Workspace not found => this predicate can never match + // We might want to throw here? We can be pretty sure the user did + // something wrong at this point + + if (workspace == null) return; + const value = get_1.default(workspace.manifest.raw, fieldName.id); // Field is not present => this predicate can never match + + if (typeof value === `undefined`) return; // Inject the variables into a sandbox + + const vars = { + $$: value + }; + + for (const [index, value] of checkArgv.toJavaScript().entries()) vars[`$${index}`] = value; + + const result = vm_1.default.runInNewContext(checkCode.id, vars); + + if (result) { + thread.success(point); + } + } + }, [`project_workspaces_by_descriptor/3`, `workspace_field/3`, `workspace_field_test/3`, `workspace_field_test/4`]); + + function linkProjectToSession(session, project) { + projects.set(session, project); + session.consult(`:- use_module(library(${tauModule.id})).`); + } + + exports.linkProjectToSession = linkProjectToSession; + + /***/ }), + /* 15 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(16); + + /** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ + function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; + } + + module.exports = get; + + + /***/ }), + /* 16 */ + /***/ (function(module, exports, __webpack_require__) { + + var castPath = __webpack_require__(17), + toKey = __webpack_require__(66); + + /** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; + } + + module.exports = baseGet; + + + /***/ }), + /* 17 */ + /***/ (function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(18), + isKey = __webpack_require__(19), + stringToPath = __webpack_require__(28), + toString = __webpack_require__(63); + + /** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ + function castPath(value, object) { + if (isArray(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); + } + + module.exports = castPath; + + + /***/ }), + /* 18 */ + /***/ (function(module, exports) { + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray = Array.isArray; + + module.exports = isArray; + + + /***/ }), + /* 19 */ + /***/ (function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(18), + isSymbol = __webpack_require__(20); + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); + } + + module.exports = isKey; + + + /***/ }), + /* 20 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseGetTag = __webpack_require__(21), + isObjectLike = __webpack_require__(27); + + /** `Object#toString` result references. */ + var symbolTag = '[object Symbol]'; + + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); + } + + module.exports = isSymbol; + + + /***/ }), + /* 21 */ + /***/ (function(module, exports, __webpack_require__) { + + var Symbol = __webpack_require__(22), + getRawTag = __webpack_require__(25), + objectToString = __webpack_require__(26); + + /** `Object#toString` result references. */ + var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + + /** Built-in value references. */ + var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + + /** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); + } + + module.exports = baseGetTag; + + + /***/ }), + /* 22 */ + /***/ (function(module, exports, __webpack_require__) { + + var root = __webpack_require__(23); + + /** Built-in value references. */ + var Symbol = root.Symbol; + + module.exports = Symbol; + + + /***/ }), + /* 23 */ + /***/ (function(module, exports, __webpack_require__) { + + var freeGlobal = __webpack_require__(24); + + /** Detect free variable `self`. */ + var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root = freeGlobal || freeSelf || Function('return this')(); + + module.exports = root; + + + /***/ }), + /* 24 */ + /***/ (function(module, exports) { + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + + module.exports = freeGlobal; + + + /***/ }), + /* 25 */ + /***/ (function(module, exports, __webpack_require__) { + + var Symbol = __webpack_require__(22); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto.toString; + + /** Built-in value references. */ + var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + + /** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ + function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; + } + + module.exports = getRawTag; + + + /***/ }), + /* 26 */ + /***/ (function(module, exports) { + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto.toString; + + /** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ + function objectToString(value) { + return nativeObjectToString.call(value); + } + + module.exports = objectToString; + + + /***/ }), + /* 27 */ + /***/ (function(module, exports) { + + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + function isObjectLike(value) { + return value != null && typeof value == 'object'; + } + + module.exports = isObjectLike; + + + /***/ }), + /* 28 */ + /***/ (function(module, exports, __webpack_require__) { + + var memoizeCapped = __webpack_require__(29); + + /** Used to match property names within property paths. */ + var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ + var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + }); + + module.exports = stringToPath; + + + /***/ }), + /* 29 */ + /***/ (function(module, exports, __webpack_require__) { + + var memoize = __webpack_require__(30); + + /** Used as the maximum memoize cache size. */ + var MAX_MEMOIZE_SIZE = 500; + + /** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ + function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; + } + + module.exports = memoizeCapped; + + + /***/ }), + /* 30 */ + /***/ (function(module, exports, __webpack_require__) { + + var MapCache = __webpack_require__(31); + + /** Error message constants. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ + function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; + } + + // Expose `MapCache`. + memoize.Cache = MapCache; + + module.exports = memoize; + + + /***/ }), + /* 31 */ + /***/ (function(module, exports, __webpack_require__) { + + var mapCacheClear = __webpack_require__(32), + mapCacheDelete = __webpack_require__(57), + mapCacheGet = __webpack_require__(60), + mapCacheHas = __webpack_require__(61), + mapCacheSet = __webpack_require__(62); + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + module.exports = MapCache; + + + /***/ }), + /* 32 */ + /***/ (function(module, exports, __webpack_require__) { + + var Hash = __webpack_require__(33), + ListCache = __webpack_require__(48), + Map = __webpack_require__(56); + + /** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ + function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; + } + + module.exports = mapCacheClear; + + + /***/ }), + /* 33 */ + /***/ (function(module, exports, __webpack_require__) { + + var hashClear = __webpack_require__(34), + hashDelete = __webpack_require__(44), + hashGet = __webpack_require__(45), + hashHas = __webpack_require__(46), + hashSet = __webpack_require__(47); + + /** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + + module.exports = Hash; + + + /***/ }), + /* 34 */ + /***/ (function(module, exports, __webpack_require__) { + + var nativeCreate = __webpack_require__(35); + + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; + } + + module.exports = hashClear; + + + /***/ }), + /* 35 */ + /***/ (function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(36); + + /* Built-in method references that are verified to be native. */ + var nativeCreate = getNative(Object, 'create'); + + module.exports = nativeCreate; + + + /***/ }), + /* 36 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseIsNative = __webpack_require__(37), + getValue = __webpack_require__(43); + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + module.exports = getNative; + + + /***/ }), + /* 37 */ + /***/ (function(module, exports, __webpack_require__) { + + var isFunction = __webpack_require__(38), + isMasked = __webpack_require__(40), + isObject = __webpack_require__(39), + toSource = __webpack_require__(42); + + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used for built-in method references. */ + var funcProto = Function.prototype, + objectProto = Object.prototype; + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + + module.exports = baseIsNative; + + + /***/ }), + /* 38 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseGetTag = __webpack_require__(21), + isObject = __webpack_require__(39); + + /** `Object#toString` result references. */ + var asyncTag = '[object AsyncFunction]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + if (!isObject(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + + module.exports = isFunction; + + + /***/ }), + /* 39 */ + /***/ (function(module, exports) { + + /** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ + function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); + } + + module.exports = isObject; + + + /***/ }), + /* 40 */ + /***/ (function(module, exports, __webpack_require__) { + + var coreJsData = __webpack_require__(41); + + /** Used to detect methods masquerading as native. */ + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; + }()); + + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); + } + + module.exports = isMasked; + + + /***/ }), + /* 41 */ + /***/ (function(module, exports, __webpack_require__) { + + var root = __webpack_require__(23); + + /** Used to detect overreaching core-js shims. */ + var coreJsData = root['__core-js_shared__']; + + module.exports = coreJsData; + + + /***/ }), + /* 42 */ + /***/ (function(module, exports) { + + /** Used for built-in method references. */ + var funcProto = Function.prototype; + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + module.exports = toSource; + + + /***/ }), + /* 43 */ + /***/ (function(module, exports) { + + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function getValue(object, key) { + return object == null ? undefined : object[key]; + } + + module.exports = getValue; + + + /***/ }), + /* 44 */ + /***/ (function(module, exports) { + + /** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; + } + + module.exports = hashDelete; + + + /***/ }), + /* 45 */ + /***/ (function(module, exports, __webpack_require__) { + + var nativeCreate = __webpack_require__(35); + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; + } + + module.exports = hashGet; + + + /***/ }), + /* 46 */ + /***/ (function(module, exports, __webpack_require__) { + + var nativeCreate = __webpack_require__(35); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); + } + + module.exports = hashHas; + + + /***/ }), + /* 47 */ + /***/ (function(module, exports, __webpack_require__) { + + var nativeCreate = __webpack_require__(35); + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + + /** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ + function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; + } + + module.exports = hashSet; + + + /***/ }), + /* 48 */ + /***/ (function(module, exports, __webpack_require__) { + + var listCacheClear = __webpack_require__(49), + listCacheDelete = __webpack_require__(50), + listCacheGet = __webpack_require__(53), + listCacheHas = __webpack_require__(54), + listCacheSet = __webpack_require__(55); + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + + module.exports = ListCache; + + + /***/ }), + /* 49 */ + /***/ (function(module, exports) { + + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + + module.exports = listCacheClear; + + + /***/ }), + /* 50 */ + /***/ (function(module, exports, __webpack_require__) { + + var assocIndexOf = __webpack_require__(51); + + /** Used for built-in method references. */ + var arrayProto = Array.prototype; + + /** Built-in value references. */ + var splice = arrayProto.splice; + + /** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; + } + + module.exports = listCacheDelete; + + + /***/ }), + /* 51 */ + /***/ (function(module, exports, __webpack_require__) { + + var eq = __webpack_require__(52); + + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + + module.exports = assocIndexOf; + + + /***/ }), + /* 52 */ + /***/ (function(module, exports) { + + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + function eq(value, other) { + return value === other || (value !== value && other !== other); + } + + module.exports = eq; + + + /***/ }), + /* 53 */ + /***/ (function(module, exports, __webpack_require__) { + + var assocIndexOf = __webpack_require__(51); + + /** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; + } + + module.exports = listCacheGet; + + + /***/ }), + /* 54 */ + /***/ (function(module, exports, __webpack_require__) { + + var assocIndexOf = __webpack_require__(51); + + /** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + + module.exports = listCacheHas; + + + /***/ }), + /* 55 */ + /***/ (function(module, exports, __webpack_require__) { + + var assocIndexOf = __webpack_require__(51); + + /** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ + function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + + module.exports = listCacheSet; + + + /***/ }), + /* 56 */ + /***/ (function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(36), + root = __webpack_require__(23); + + /* Built-in method references that are verified to be native. */ + var Map = getNative(root, 'Map'); + + module.exports = Map; + + + /***/ }), + /* 57 */ + /***/ (function(module, exports, __webpack_require__) { + + var getMapData = __webpack_require__(58); + + /** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; + } + + module.exports = mapCacheDelete; + + + /***/ }), + /* 58 */ + /***/ (function(module, exports, __webpack_require__) { + + var isKeyable = __webpack_require__(59); + + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; + } + + module.exports = getMapData; + + + /***/ }), + /* 59 */ + /***/ (function(module, exports) { + + /** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ + function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); + } + + module.exports = isKeyable; + + + /***/ }), + /* 60 */ + /***/ (function(module, exports, __webpack_require__) { + + var getMapData = __webpack_require__(58); + + /** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + + module.exports = mapCacheGet; + + + /***/ }), + /* 61 */ + /***/ (function(module, exports, __webpack_require__) { + + var getMapData = __webpack_require__(58); + + /** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + + module.exports = mapCacheHas; + + + /***/ }), + /* 62 */ + /***/ (function(module, exports, __webpack_require__) { + + var getMapData = __webpack_require__(58); + + /** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ + function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; + } + + module.exports = mapCacheSet; + + + /***/ }), + /* 63 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseToString = __webpack_require__(64); + + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + function toString(value) { + return value == null ? '' : baseToString(value); + } + + module.exports = toString; + + + /***/ }), + /* 64 */ + /***/ (function(module, exports, __webpack_require__) { + + var Symbol = __webpack_require__(22), + arrayMap = __webpack_require__(65), + isArray = __webpack_require__(18), + isSymbol = __webpack_require__(20); + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + module.exports = baseToString; + + + /***/ }), + /* 65 */ + /***/ (function(module, exports) { + + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + + module.exports = arrayMap; + + + /***/ }), + /* 66 */ + /***/ (function(module, exports, __webpack_require__) { + + var isSymbol = __webpack_require__(20); + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + module.exports = toKey; + + + /***/ }), + /* 67 */ + /***/ (function(module, exports) { + + module.exports = require("vm"); + + /***/ }), + /* 68 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + + + var __decorate = this && this.__decorate || function (decorators, target, key, desc) { + var c = arguments.length, + r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, + d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + }; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + const cli_1 = __webpack_require__(3); + + const core_1 = __webpack_require__(1); + + const clipanion_1 = __webpack_require__(4); + + const Constraints_1 = __webpack_require__(5); // eslint-disable-next-line arca/no-default-export + + + class ConstraintsSourceCommand extends cli_1.BaseCommand { + constructor() { + super(...arguments); + this.verbose = false; + } + + async execute() { + const configuration = await core_1.Configuration.find(this.context.cwd, this.context.plugins); + const { + project + } = await core_1.Project.find(configuration, this.context.cwd); + const constraints = await Constraints_1.Constraints.find(project); + this.context.stdout.write(this.verbose ? constraints.fullSource : constraints.source); + } + + } + + ConstraintsSourceCommand.usage = clipanion_1.Command.Usage({ + category: `Constraints-related commands`, + description: `print the source code for the constraints`, + details: ` + This command will print the Prolog source code used by the constraints engine. Adding the \`-v,--verbose\` flag will print the *full* source code, including the fact database automatically compiled from your workspaces manifests. + `, + examples: [[`Prints the source code`, `yarn constraints source`], [`Print the source code and the fact database`, `yarn constraints source -v`]] + }); + + __decorate([clipanion_1.Command.Boolean(`-v,--verbose`)], ConstraintsSourceCommand.prototype, "verbose", void 0); + + __decorate([clipanion_1.Command.Path(`constraints`, `source`)], ConstraintsSourceCommand.prototype, "execute", null); + + exports.default = ConstraintsSourceCommand; + + /***/ }), + /* 69 */ + /***/ (function(module, exports, __webpack_require__) { + + "use strict"; + + + var __decorate = this && this.__decorate || function (decorators, target, key, desc) { + var c = arguments.length, + r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, + d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + }; + + var __importDefault = this && this.__importDefault || function (mod) { + return mod && mod.__esModule ? mod : { + "default": mod + }; + }; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + const cli_1 = __webpack_require__(3); + + const core_1 = __webpack_require__(1); + + const core_2 = __webpack_require__(1); + + const core_3 = __webpack_require__(1); + + const clipanion_1 = __webpack_require__(4); + + const get_1 = __importDefault(__webpack_require__(15)); + + const set_1 = __importDefault(__webpack_require__(70)); + + const unset_1 = __importDefault(__webpack_require__(76)); + + const Constraints_1 = __webpack_require__(5); // eslint-disable-next-line arca/no-default-export + + + class ConstraintsCheckCommand extends cli_1.BaseCommand { + constructor() { + super(...arguments); + this.fix = false; + } + + async execute() { + for (let t = 0; t < 10; ++t) { + const configuration = await core_1.Configuration.find(this.context.cwd, this.context.plugins); + const { + project + } = await core_1.Project.find(configuration, this.context.cwd); + const constraints = await Constraints_1.Constraints.find(project); + const toSave = new Set(); + const report = await core_2.StreamReport.start({ + configuration, + stdout: this.context.stdout + }, async report => { + const result = await constraints.process(); + await processDependencyConstraints(toSave, result.enforcedDependencies, { + fix: this.fix, + configuration, + report + }); + await processFieldConstraints(toSave, result.enforcedFields, { + fix: this.fix, + configuration, + report + }); + + for (const workspace of toSave) { + workspace.persistManifest(); + } + }); + if (report.hasErrors()) return report.exitCode(); + + if (!this.fix || toSave.size > 0) { + return 0; + } + } + + return 1; + } + + } + + ConstraintsCheckCommand.usage = clipanion_1.Command.Usage({ + category: `Constraints-related commands`, + description: `check that the project constraints are met`, + details: ` + This command will run constraints on your project and emit errors for each one that is found but isn't met. If any error is emitted the process will exit with a non-zero exit code. + + If the \`--fix\` flag is used, Yarn will attempt to automatically fix the issues the best it can, following a multi-pass process (with a maximum of 10 iterations). Some ambiguous patterns cannot be autofixed, in which case you'll have to manually specify the right resolution. + + For more information as to how to write constraints, please consult our dedicated page on our website: https://yarnpkg.com/features/constraints. + `, + examples: [[`Check that all constraints are satisfied`, `yarn constraints`], [`Autofix all unmet constraints`, `yarn constraints --fix`]] + }); + + __decorate([clipanion_1.Command.Boolean(`--fix`)], ConstraintsCheckCommand.prototype, "fix", void 0); + + __decorate([clipanion_1.Command.Path(`constraints`)], ConstraintsCheckCommand.prototype, "execute", null); + + exports.default = ConstraintsCheckCommand; + + async function processDependencyConstraints(toSave, enforcedDependencies, { + configuration, + fix, + report + }) { + let hasFixes = false; + const allIdents = new Map(); + const byWorkspaces = new Map(); + + for (const { + workspace, + dependencyIdent, + dependencyRange, + dependencyType + } of enforcedDependencies) { + let byWorkspacesStore = byWorkspaces.get(workspace); + if (typeof byWorkspacesStore === `undefined`) byWorkspaces.set(workspace, byWorkspacesStore = new Map()); + let byIdentStore = byWorkspacesStore.get(dependencyIdent.identHash); + if (typeof byIdentStore === `undefined`) byWorkspacesStore.set(dependencyIdent.identHash, byIdentStore = new Map()); + let byDependencyTypeStore = byIdentStore.get(dependencyType); + if (typeof byDependencyTypeStore === `undefined`) byIdentStore.set(dependencyType, byDependencyTypeStore = new Set()); + allIdents.set(dependencyIdent.identHash, dependencyIdent); + byDependencyTypeStore.add(dependencyRange); + } + + for (const [workspace, byWorkspacesStore] of byWorkspaces) { + for (const [identHash, byIdentStore] of byWorkspacesStore) { + const dependencyIdent = allIdents.get(identHash); + if (typeof dependencyIdent === `undefined`) throw new Error(`Assertion failed: The ident should have been registered`); + + for (const [dependencyType, byDependencyTypeStore] of byIdentStore) { + const expectedRanges = [...byDependencyTypeStore]; + + if (expectedRanges.length > 2) { + report.reportError(core_2.MessageName.CONSTRAINTS_AMBIGUITY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must depend on ${core_3.structUtils.prettyIdent(configuration, dependencyIdent)} via conflicting ranges ${expectedRanges.slice(0, -1).map(expectedRange => core_3.structUtils.prettyRange(configuration, String(expectedRange))).join(`, `)}, and ${core_3.structUtils.prettyRange(configuration, String(expectedRanges[expectedRanges.length - 1]))} (in ${dependencyType})`); + } else if (expectedRanges.length > 1) { + report.reportError(core_2.MessageName.CONSTRAINTS_AMBIGUITY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must depend on ${core_3.structUtils.prettyIdent(configuration, dependencyIdent)} via conflicting ranges ${core_3.structUtils.prettyRange(configuration, String(expectedRanges[0]))} and ${core_3.structUtils.prettyRange(configuration, String(expectedRanges[1]))} (in ${dependencyType})`); + } else { + const dependencyDescriptor = workspace.manifest[dependencyType].get(dependencyIdent.identHash); + const [expectedRange] = expectedRanges; + + if (expectedRange !== null) { + if (!dependencyDescriptor) { + if (fix) { + workspace.manifest[dependencyType].set(dependencyIdent.identHash, core_3.structUtils.makeDescriptor(dependencyIdent, expectedRange)); + toSave.add(workspace); + hasFixes = true; + } else { + report.reportError(core_2.MessageName.CONSTRAINTS_MISSING_DEPENDENCY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must depend on ${core_3.structUtils.prettyIdent(configuration, dependencyIdent)} (via ${core_3.structUtils.prettyRange(configuration, expectedRange)}), but doesn't (in ${dependencyType})`); + } + } else if (dependencyDescriptor.range !== expectedRange) { + if (fix) { + workspace.manifest[dependencyType].set(dependencyIdent.identHash, core_3.structUtils.makeDescriptor(dependencyIdent, expectedRange)); + toSave.add(workspace); + hasFixes = true; + } else { + report.reportError(core_2.MessageName.CONSTRAINTS_INCOMPATIBLE_DEPENDENCY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must depend on ${core_3.structUtils.prettyIdent(configuration, dependencyIdent)} via ${core_3.structUtils.prettyRange(configuration, expectedRange)}, but uses ${core_3.structUtils.prettyRange(configuration, dependencyDescriptor.range)} instead (in ${dependencyType})`); + } + } + } else { + if (dependencyDescriptor) { + if (fix) { + workspace.manifest[dependencyType].delete(dependencyIdent.identHash); + toSave.add(workspace); + hasFixes = true; + } else { + report.reportError(core_2.MessageName.CONSTRAINTS_EXTRANEOUS_DEPENDENCY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} has an extraneous dependency on ${core_3.structUtils.prettyIdent(configuration, dependencyIdent)} (in ${dependencyType})`); + } + } + } + } + } + } + } + + return hasFixes; + } + + async function processFieldConstraints(toSave, enforcedFields, { + configuration, + fix, + report + }) { + let hasFixes = false; + const byWorkspaces = new Map(); + + for (const { + workspace, + fieldPath, + fieldValue + } of enforcedFields) { + const byWorkspacesStore = core_1.miscUtils.getMapWithDefault(byWorkspaces, workspace); + const byPathStore = core_1.miscUtils.getSetWithDefault(byWorkspacesStore, fieldPath); + byPathStore.add(fieldValue); + } + + for (const [workspace, byWorkspacesStore] of byWorkspaces) { + for (const [fieldPath, byPathStore] of byWorkspacesStore) { + const expectedValues = [...byPathStore]; + + if (expectedValues.length > 2) { + report.reportError(core_2.MessageName.CONSTRAINTS_AMBIGUITY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must have a field ${configuration.format(fieldPath, `cyan`)} set to conflicting values ${expectedValues.slice(0, -1).map(expectedValue => configuration.format(String(expectedValue), `magenta`)).join(`, `)}, or ${configuration.format(String(expectedValues[expectedValues.length - 1]), `magenta`)}`); + } else if (expectedValues.length > 1) { + report.reportError(core_2.MessageName.CONSTRAINTS_AMBIGUITY, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must have a field ${configuration.format(fieldPath, `cyan`)} set to conflicting values ${configuration.format(String(expectedValues[0]), `magenta`)} or ${configuration.format(String(expectedValues[1]), `magenta`)}`); + } else { + const actualValue = get_1.default(workspace.manifest.raw, fieldPath); + const [expectedValue] = expectedValues; + + if (expectedValue !== null) { + if (actualValue === undefined) { + if (fix) { + await setWorkspaceField(workspace, fieldPath, expectedValue); + toSave.add(workspace); + hasFixes = true; + } else { + report.reportError(core_2.MessageName.CONSTRAINTS_MISSING_FIELD, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must have a field ${configuration.format(fieldPath, `cyan`)} set to ${configuration.format(String(expectedValue), `magenta`)}, but doesn't`); + } + } else if (JSON.stringify(actualValue) !== expectedValue) { + if (fix) { + await setWorkspaceField(workspace, fieldPath, expectedValue); + toSave.add(workspace); + hasFixes = true; + } else { + report.reportError(core_2.MessageName.CONSTRAINTS_INCOMPATIBLE_FIELD, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} must have a field ${configuration.format(fieldPath, `cyan`)} set to ${configuration.format(String(expectedValue), `magenta`)}, but is set to ${configuration.format(JSON.stringify(actualValue), `magenta`)} instead`); + } + } + } else { + if (actualValue !== undefined && actualValue !== null) { + if (fix) { + await setWorkspaceField(workspace, fieldPath, null); + toSave.add(workspace); + hasFixes = true; + } else { + report.reportError(core_2.MessageName.CONSTRAINTS_EXTRANEOUS_FIELD, `${core_3.structUtils.prettyWorkspace(configuration, workspace)} has an extraneous field ${configuration.format(fieldPath, `cyan`)} set to ${configuration.format(String(expectedValue), `magenta`)}`); + } + } + } + } + } + } + + return hasFixes; + } + + async function setWorkspaceField(workspace, fieldPath, value) { + if (value === null) { + unset_1.default(workspace.manifest.raw, fieldPath); + } else { + set_1.default(workspace.manifest.raw, fieldPath, JSON.parse(value)); + } + } + + /***/ }), + /* 70 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseSet = __webpack_require__(71); + + /** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ + function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); + } + + module.exports = set; + + + /***/ }), + /* 71 */ + /***/ (function(module, exports, __webpack_require__) { + + var assignValue = __webpack_require__(72), + castPath = __webpack_require__(17), + isIndex = __webpack_require__(75), + isObject = __webpack_require__(39), + toKey = __webpack_require__(66); + + /** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + function baseSet(object, path, value, customizer) { + if (!isObject(object)) { + return object; + } + path = castPath(path, object); + + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined; + if (newValue === undefined) { + newValue = isObject(objValue) + ? objValue + : (isIndex(path[index + 1]) ? [] : {}); + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; + } + + module.exports = baseSet; + + + /***/ }), + /* 72 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseAssignValue = __webpack_require__(73), + eq = __webpack_require__(52); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + module.exports = assignValue; + + + /***/ }), + /* 73 */ + /***/ (function(module, exports, __webpack_require__) { + + var defineProperty = __webpack_require__(74); + + /** + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty) { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; + } + } + + module.exports = baseAssignValue; + + + /***/ }), + /* 74 */ + /***/ (function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(36); + + var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} + }()); + + module.exports = defineProperty; + + + /***/ }), + /* 75 */ + /***/ (function(module, exports) { + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); + } + + module.exports = isIndex; + + + /***/ }), + /* 76 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseUnset = __webpack_require__(77); + + /** + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 7 } }] }; + * _.unset(object, 'a[0].b.c'); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + * + * _.unset(object, ['a', '0', 'b', 'c']); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + */ + function unset(object, path) { + return object == null ? true : baseUnset(object, path); + } + + module.exports = unset; + + + /***/ }), + /* 77 */ + /***/ (function(module, exports, __webpack_require__) { + + var castPath = __webpack_require__(17), + last = __webpack_require__(78), + parent = __webpack_require__(79), + toKey = __webpack_require__(66); + + /** + * The base implementation of `_.unset`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The property path to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + */ + function baseUnset(object, path) { + path = castPath(path, object); + object = parent(object, path); + return object == null || delete object[toKey(last(path))]; + } + + module.exports = baseUnset; + + + /***/ }), + /* 78 */ + /***/ (function(module, exports) { + + /** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ + function last(array) { + var length = array == null ? 0 : array.length; + return length ? array[length - 1] : undefined; + } + + module.exports = last; + + + /***/ }), + /* 79 */ + /***/ (function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(16), + baseSlice = __webpack_require__(80); + + /** + * Gets the parent value at `path` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} path The path to get the parent value of. + * @returns {*} Returns the parent value. + */ + function parent(object, path) { + return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); + } + + module.exports = parent; + + + /***/ }), + /* 80 */ + /***/ (function(module, exports) { + + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; + } + + module.exports = baseSlice; + + + /***/ }) + /******/ ]); + return plugin; + }, +}; diff --git a/Makefile b/Makefile index a291d780cc91..22a6c917a906 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ FLOW_COMMIT = a1f9a4c709dcebb27a5084acf47755fbae699c25 TEST262_COMMIT = d9740c172652d36194ceae3ed3d0484e9968ebc3 TYPESCRIPT_COMMIT = da8633212023517630de5f3620a23736b63234b1 -FORCE_PUBLISH = -f @babel/runtime -f @babel/runtime-corejs2 -f @babel/runtime-corejs3 -f @babel/standalone +FORCE_PUBLISH = -f @babel/runtime -f @babel/runtime-corejs3 -f @babel/standalone # Fix color output until TravisCI fixes https://github.com/travis-ci/travis-ci/issues/7967 export FORCE_COLOR = true @@ -33,7 +33,7 @@ build-bundle: clean clean-lib $(MAKE) build-typings $(MAKE) build-dist -build-bundle-ci: bootstrap-only +build-bundle-ci: bootstrap-only-ci $(MAKE) build-bundle generate-standalone: @@ -50,14 +50,12 @@ build-flow-typings: build-typescript-typings: $(NODE) packages/babel-types/scripts/generators/typescript.js > packages/babel-types/lib/index.d.ts -build-standalone: build-babel-standalone +build-standalone: + $(YARN) gulp build-babel-standalone build-standalone-ci: build-bundle-ci $(MAKE) build-standalone -build-babel-standalone: - $(YARN) gulp build-babel-standalone - prepublish-build-standalone: BABEL_ENV=production IS_PUBLISH=true $(YARN) gulp build-babel-standalone @@ -78,34 +76,31 @@ build-no-bundle: clean clean-lib # Babel-transform-fixture-test-runner requires minified polyfill for performance $(MAKE) generate-type-helpers build-typings build-polyfill-dist -build-no-bundle-ci: bootstrap-only +build-no-bundle-ci: bootstrap-only-ci $(MAKE) build-no-bundle watch: build-no-bundle BABEL_ENV=development $(YARN) gulp watch -code-quality-ci: build-no-bundle-ci - $(MAKE) flowcheck-ci lint-ci +code-quality-ci: flowcheck-ci lint-js-ci lint-ts-ci check-compat-data-ci -flowcheck-ci: +flowcheck-ci: build-no-bundle-ci $(MAKE) flow -code-quality: flow lint - -flow: - $(YARN) flow check --strip-root - -lint-ci: lint-js-ci lint-ts-ci check-compat-data-ci - -lint-js-ci: +lint-js-ci: build-no-bundle-ci $(MAKE) lint-js -lint-ts-ci: +lint-ts-ci: build-no-bundle-ci $(MAKE) lint-ts -check-compat-data-ci: +check-compat-data-ci: build-no-bundle-ci $(MAKE) check-compat-data +code-quality: flow lint + +flow: + $(YARN) flow check --strip-root + lint: lint-js lint-ts lint-js: @@ -147,9 +142,7 @@ test-only: test: lint test-only -test-ci: jest-ci - -jest-ci: build-standalone-ci +test-ci: build-standalone-ci BABEL_ENV=test $(YARN) jest --maxWorkers=4 --ci $(MAKE) test-clean @@ -256,7 +249,10 @@ endif $(MAKE) clean bootstrap-only: clean-all - yarn install + $(YARN) install + +bootstrap-only-ci: + $(YARN) install bootstrap: bootstrap-only $(MAKE) build @@ -267,9 +263,7 @@ clean-lib: clean-runtime-helpers: rm -f packages/babel-runtime/helpers/**/*.js - rm -f packages/babel-runtime-corejs2/helpers/**/*.js rm -f packages/babel-runtime-corejs3/helpers/**/*.js - rm -rf packages/babel-runtime-corejs2/core-js clean-all: rm -rf node_modules diff --git a/babel.config.js b/babel.config.js index 24dfc34ff256..ab45b6e05356 100644 --- a/babel.config.js +++ b/babel.config.js @@ -26,7 +26,7 @@ module.exports = function (api) { let transformRuntimeOptions; - const nodeVersion = "6.9"; + const nodeVersion = "10.13"; // The vast majority of our src files are modules, but we use // unambiguous to keep things simple until we get around to renaming // the modules to be more easily distinguished from CommonJS @@ -160,44 +160,24 @@ module.exports = function (api) { return config; }; -// !!! WARNING !!! Hacks are coming - // import() uses file:// URLs for absolute imports, while require() uses // file paths. // Since this isn't handled by @babel/plugin-transform-modules-commonjs, // we must handle it here. -// However, fileURLToPath is only supported starting from Node.js 10. -// In older versions, we can remove the pathToFileURL call so that it keeps -// the original absolute path. // NOTE: This plugin must run before @babel/plugin-transform-modules-commonjs, // and assumes that the target is the current node version. -function dynamicImportUrlToPath({ template, env }) { - const currentNodeSupportsURL = - !!require("url").pathToFileURL && env() !== "test-legacy"; // test-legacy is run on legacy node versions without pathToFileURL support - if (currentNodeSupportsURL) { - return { - visitor: { - CallExpression(path) { - if (path.get("callee").isImport()) { - path.get("arguments.0").replaceWith( - template.expression.ast` - require("url").fileURLToPath(${path.node.arguments[0]}) - ` - ); - } - }, - }, - }; - } else { - // TODO: Remove in Babel 8 (it's not needed when using Node 10) - return { - visitor: { - CallExpression(path) { - if (path.get("callee").isIdentifier({ name: "pathToFileURL" })) { - path.replaceWith(path.get("arguments.0")); - } - }, +function dynamicImportUrlToPath({ template }) { + return { + visitor: { + CallExpression(path) { + if (path.get("callee").isImport()) { + path.get("arguments.0").replaceWith( + template.expression.ast` + require("url").fileURLToPath(${path.node.arguments[0]}) + ` + ); + } }, - }; - } + }, + }; } diff --git a/lib/third-party-libs.js.flow b/lib/third-party-libs.js.flow index f9723ea6fe4e..f114c0bc1ef6 100644 --- a/lib/third-party-libs.js.flow +++ b/lib/third-party-libs.js.flow @@ -6,12 +6,11 @@ declare module "debug" { declare export default (namespace: string) => (formatter: string, ...args: any[]) => void; } -declare module "resolve" { - declare export default { - (string, {| basedir: string |}, (err: ?Error, res: string) => void): void; - sync: (string, {| basedir: string |}) => string; - }; -} +declare var require: { + resolve(specifier: string, opts?: { + paths: string[] + }): string, +}; declare module "json5" { declare export default { diff --git a/package.json b/package.json index ed089a263d6c..37f182b30e66 100644 --- a/package.json +++ b/package.json @@ -50,7 +50,7 @@ "gulp-filter": "^5.1.0", "gulp-newer": "^1.0.0", "gulp-plumber": "^1.2.1", - "husky": "^3.0.0", + "husky": "^4.2.3", "jest": "^26.6.1", "lerna-changelog": "^0.5.0", "lint-staged": "^9.2.0", diff --git a/packages/babel-cli/package.json b/packages/babel-cli/package.json index 01fa9efde35c..7c4002ed501e 100644 --- a/packages/babel-cli/package.json +++ b/packages/babel-cli/package.json @@ -28,12 +28,10 @@ "fs-readdir-recursive": "^1.1.0", "glob": "^7.0.0", "lodash": "^4.17.19", - "make-dir": "^2.1.0", - "slash": "^2.0.0", + "slash": "^3.0.0", "source-map": "^0.5.0" }, "optionalDependencies": { - "@nicolo-ribaudo/chokidar-2": "^2.1.8", "chokidar": "^3.4.0" }, "peerDependencies": { diff --git a/packages/babel-cli/src/babel/dir.js b/packages/babel-cli/src/babel/dir.js index bbdcf4ac3286..97e2f0e2f82e 100644 --- a/packages/babel-cli/src/babel/dir.js +++ b/packages/babel-cli/src/babel/dir.js @@ -1,7 +1,6 @@ // @flow import debounce from "lodash/debounce"; -import { sync as makeDirSync } from "make-dir"; import slash from "slash"; import path from "path"; import fs from "fs"; @@ -17,7 +16,7 @@ const FILE_TYPE = Object.freeze({ }); function outputFileSync(filePath: string, data: string | Buffer): void { - makeDirSync(path.dirname(filePath)); + fs.mkdirSync(path.dirname(filePath), { recursive: true }); fs.writeFileSync(filePath, data); } @@ -163,7 +162,7 @@ export default async function ({ util.deleteDir(cliOptions.outDir); } - makeDirSync(cliOptions.outDir); + fs.mkdirSync(cliOptions.outDir, { recursive: true }); startTime = process.hrtime(); diff --git a/packages/babel-cli/src/babel/file.js b/packages/babel-cli/src/babel/file.js index a6927157d524..71478fafdb9e 100644 --- a/packages/babel-cli/src/babel/file.js +++ b/packages/babel-cli/src/babel/file.js @@ -3,7 +3,6 @@ import convertSourceMap from "convert-source-map"; import sourceMap from "source-map"; import slash from "slash"; -import { sync as makeDirSync } from "make-dir"; import path from "path"; import fs from "fs"; @@ -89,7 +88,7 @@ export default async function ({ const result = buildResult(fileResults); if (cliOptions.outFile) { - makeDirSync(path.dirname(cliOptions.outFile)); + fs.mkdirSync(path.dirname(cliOptions.outFile), { recursive: true }); // we've requested for a sourcemap to be written to disk if (babelOptions.sourceMaps && babelOptions.sourceMaps !== "inline") { diff --git a/packages/babel-cli/src/babel/util.js b/packages/babel-cli/src/babel/util.js index a147d5a79277..868382232d02 100644 --- a/packages/babel-cli/src/babel/util.js +++ b/packages/babel-cli/src/babel/util.js @@ -116,10 +116,7 @@ process.on("uncaughtException", function (err) { export function requireChokidar(): Object { try { - // todo(babel 8): revert `@nicolo-ribaudo/chokidar-2` hack - return parseInt(process.version) >= 8 - ? require("chokidar") - : require("@nicolo-ribaudo/chokidar-2"); + return require("chokidar"); } catch (err) { console.error( "The optional dependency chokidar failed to install and is required for " + diff --git a/packages/babel-cli/test/index.js b/packages/babel-cli/test/index.js index 7cedb49e334c..0f9d673ed4cf 100644 --- a/packages/babel-cli/test/index.js +++ b/packages/babel-cli/test/index.js @@ -1,7 +1,6 @@ const readdir = require("fs-readdir-recursive"); const helper = require("@babel/helper-fixtures"); const rimraf = require("rimraf"); -const { sync: makeDirSync } = require("make-dir"); const child = require("child_process"); const escapeRegExp = require("lodash/escapeRegExp"); const merge = require("lodash/merge"); @@ -17,7 +16,7 @@ const fileFilter = function (x) { }; const outputFileSync = function (filePath, data) { - makeDirSync(path.dirname(filePath)); + fs.mkdirSync(path.dirname(filePath), { recursive: true }); fs.writeFileSync(filePath, data); }; diff --git a/packages/babel-compat-data/corejs2-built-ins.js b/packages/babel-compat-data/corejs2-built-ins.js deleted file mode 100644 index ccbe72f0d58b..000000000000 --- a/packages/babel-compat-data/corejs2-built-ins.js +++ /dev/null @@ -1,4 +0,0 @@ -// Node < 13.3 doesn't support export maps in package.json. -// Use this proxy file as a fallback. - -module.exports = require("./data/corejs2-built-ins.json"); diff --git a/packages/babel-compat-data/data/corejs2-built-ins.json b/packages/babel-compat-data/data/corejs2-built-ins.json deleted file mode 100644 index ade6acc19f72..000000000000 --- a/packages/babel-compat-data/data/corejs2-built-ins.json +++ /dev/null @@ -1,1690 +0,0 @@ -{ - "es6.array.copy-within": { - "chrome": "45", - "opera": "32", - "edge": "12", - "firefox": "32", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "5", - "electron": "0.31" - }, - "es6.array.every": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.fill": { - "chrome": "45", - "opera": "32", - "edge": "12", - "firefox": "31", - "safari": "7.1", - "node": "4", - "ios": "8", - "samsung": "5", - "electron": "0.31" - }, - "es6.array.filter": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.find": { - "chrome": "45", - "opera": "32", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "4", - "ios": "8", - "samsung": "5", - "electron": "0.31" - }, - "es6.array.find-index": { - "chrome": "45", - "opera": "32", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "4", - "ios": "8", - "samsung": "5", - "electron": "0.31" - }, - "es7.array.flat-map": { - "chrome": "69", - "opera": "56", - "edge": "79", - "firefox": "62", - "safari": "12", - "node": "11", - "ios": "12", - "samsung": "10", - "electron": "4.0" - }, - "es6.array.for-each": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.from": { - "chrome": "51", - "opera": "38", - "edge": "15", - "firefox": "36", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es7.array.includes": { - "chrome": "47", - "opera": "34", - "edge": "14", - "firefox": "43", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.36" - }, - "es6.array.index-of": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.is-array": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "4", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.iterator": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "28", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.array.last-index-of": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.map": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.of": { - "chrome": "45", - "opera": "32", - "edge": "12", - "firefox": "25", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "5", - "electron": "0.31" - }, - "es6.array.reduce": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "3", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.reduce-right": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "3", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.some": { - "chrome": "5", - "opera": "10.10", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.array.sort": { - "chrome": "63", - "opera": "50", - "edge": "12", - "firefox": "5", - "safari": "12", - "node": "10", - "ie": "9", - "ios": "12", - "samsung": "8", - "electron": "3.0" - }, - "es6.array.species": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.date.now": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "2", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.date.to-iso-string": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "3.5", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.date.to-json": { - "chrome": "5", - "opera": "12.10", - "edge": "12", - "firefox": "4", - "safari": "10", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "10", - "samsung": "1", - "electron": "0.20" - }, - "es6.date.to-primitive": { - "chrome": "47", - "opera": "34", - "edge": "15", - "firefox": "44", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.36" - }, - "es6.date.to-string": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "2", - "safari": "3.1", - "node": "0.10", - "ie": "10", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.function.bind": { - "chrome": "7", - "opera": "12", - "edge": "12", - "firefox": "4", - "safari": "5.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.function.has-instance": { - "chrome": "51", - "opera": "38", - "edge": "15", - "firefox": "50", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.function.name": { - "chrome": "5", - "opera": "10.50", - "edge": "14", - "firefox": "2", - "safari": "4", - "node": "0.10", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.map": { - "chrome": "51", - "opera": "38", - "edge": "15", - "firefox": "53", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.math.acosh": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.asinh": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.atanh": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.cbrt": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.clz32": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "31", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.cosh": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.expm1": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.fround": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "26", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.hypot": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "27", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.imul": { - "chrome": "30", - "opera": "17", - "edge": "12", - "firefox": "23", - "safari": "7", - "node": "0.12", - "android": "4.4", - "ios": "7", - "samsung": "2", - "electron": "0.20" - }, - "es6.math.log1p": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.log10": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.log2": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.sign": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.sinh": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.tanh": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.math.trunc": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "25", - "safari": "7.1", - "node": "0.12", - "ios": "8", - "samsung": "3", - "electron": "0.20" - }, - "es6.number.constructor": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "36", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.number.epsilon": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "25", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.number.is-finite": { - "chrome": "19", - "opera": "15", - "edge": "12", - "firefox": "16", - "safari": "9", - "node": "0.12", - "android": "4.1", - "ios": "9", - "samsung": "1.5", - "electron": "0.20" - }, - "es6.number.is-integer": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "16", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.number.is-nan": { - "chrome": "19", - "opera": "15", - "edge": "12", - "firefox": "15", - "safari": "9", - "node": "0.12", - "android": "4.1", - "ios": "9", - "samsung": "1.5", - "electron": "0.20" - }, - "es6.number.is-safe-integer": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "32", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.number.max-safe-integer": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "31", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.number.min-safe-integer": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "31", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.number.parse-float": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "25", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.number.parse-int": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "25", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es6.object.assign": { - "chrome": "49", - "opera": "36", - "edge": "13", - "firefox": "36", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.object.create": { - "chrome": "5", - "opera": "12", - "edge": "12", - "firefox": "4", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es7.object.define-getter": { - "chrome": "62", - "opera": "49", - "edge": "16", - "firefox": "48", - "safari": "9", - "node": "8.10", - "ios": "9", - "samsung": "8", - "electron": "3.0" - }, - "es7.object.define-setter": { - "chrome": "62", - "opera": "49", - "edge": "16", - "firefox": "48", - "safari": "9", - "node": "8.10", - "ios": "9", - "samsung": "8", - "electron": "3.0" - }, - "es6.object.define-property": { - "chrome": "5", - "opera": "12", - "edge": "12", - "firefox": "4", - "safari": "5.1", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.object.define-properties": { - "chrome": "5", - "opera": "12", - "edge": "12", - "firefox": "4", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es7.object.entries": { - "chrome": "54", - "opera": "41", - "edge": "14", - "firefox": "47", - "safari": "10.1", - "node": "7", - "ios": "10.3", - "samsung": "6", - "electron": "1.4" - }, - "es6.object.freeze": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es6.object.get-own-property-descriptor": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es7.object.get-own-property-descriptors": { - "chrome": "54", - "opera": "41", - "edge": "15", - "firefox": "50", - "safari": "10.1", - "node": "7", - "ios": "10.3", - "samsung": "6", - "electron": "1.4" - }, - "es6.object.get-own-property-names": { - "chrome": "40", - "opera": "27", - "edge": "12", - "firefox": "33", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.object.get-prototype-of": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es7.object.lookup-getter": { - "chrome": "62", - "opera": "49", - "edge": "79", - "firefox": "36", - "safari": "9", - "node": "8.10", - "ios": "9", - "samsung": "8", - "electron": "3.0" - }, - "es7.object.lookup-setter": { - "chrome": "62", - "opera": "49", - "edge": "79", - "firefox": "36", - "safari": "9", - "node": "8.10", - "ios": "9", - "samsung": "8", - "electron": "3.0" - }, - "es6.object.prevent-extensions": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es6.object.to-string": { - "chrome": "57", - "opera": "44", - "edge": "15", - "firefox": "51", - "safari": "10", - "node": "8", - "ios": "10", - "samsung": "7", - "electron": "1.7" - }, - "es6.object.is": { - "chrome": "19", - "opera": "15", - "edge": "12", - "firefox": "22", - "safari": "9", - "node": "0.12", - "android": "4.1", - "ios": "9", - "samsung": "1.5", - "electron": "0.20" - }, - "es6.object.is-frozen": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es6.object.is-sealed": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es6.object.is-extensible": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es6.object.keys": { - "chrome": "40", - "opera": "27", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.object.seal": { - "chrome": "44", - "opera": "31", - "edge": "12", - "firefox": "35", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "4", - "electron": "0.30" - }, - "es6.object.set-prototype-of": { - "chrome": "34", - "opera": "21", - "edge": "12", - "firefox": "31", - "safari": "9", - "node": "0.12", - "ie": "11", - "ios": "9", - "samsung": "2", - "electron": "0.20" - }, - "es7.object.values": { - "chrome": "54", - "opera": "41", - "edge": "14", - "firefox": "47", - "safari": "10.1", - "node": "7", - "ios": "10.3", - "samsung": "6", - "electron": "1.4" - }, - "es6.promise": { - "chrome": "51", - "opera": "38", - "edge": "14", - "firefox": "45", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es7.promise.finally": { - "chrome": "63", - "opera": "50", - "edge": "18", - "firefox": "58", - "safari": "11.1", - "node": "10", - "ios": "11.3", - "samsung": "8", - "electron": "3.0" - }, - "es6.reflect.apply": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.construct": { - "chrome": "49", - "opera": "36", - "edge": "13", - "firefox": "49", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.define-property": { - "chrome": "49", - "opera": "36", - "edge": "13", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.delete-property": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.get": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.get-own-property-descriptor": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.get-prototype-of": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.has": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.is-extensible": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.own-keys": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.prevent-extensions": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.set": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.reflect.set-prototype-of": { - "chrome": "49", - "opera": "36", - "edge": "12", - "firefox": "42", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "0.37" - }, - "es6.regexp.constructor": { - "chrome": "50", - "opera": "37", - "edge": "79", - "firefox": "40", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "1.1" - }, - "es6.regexp.flags": { - "chrome": "49", - "opera": "36", - "edge": "79", - "firefox": "37", - "safari": "9", - "node": "6", - "ios": "9", - "samsung": "5", - "electron": "0.37" - }, - "es6.regexp.match": { - "chrome": "50", - "opera": "37", - "edge": "79", - "firefox": "49", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "1.1" - }, - "es6.regexp.replace": { - "chrome": "50", - "opera": "37", - "edge": "79", - "firefox": "49", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "1.1" - }, - "es6.regexp.split": { - "chrome": "50", - "opera": "37", - "edge": "79", - "firefox": "49", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "1.1" - }, - "es6.regexp.search": { - "chrome": "50", - "opera": "37", - "edge": "79", - "firefox": "49", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "1.1" - }, - "es6.regexp.to-string": { - "chrome": "50", - "opera": "37", - "edge": "79", - "firefox": "39", - "safari": "10", - "node": "6", - "ios": "10", - "samsung": "5", - "electron": "1.1" - }, - "es6.set": { - "chrome": "51", - "opera": "38", - "edge": "15", - "firefox": "53", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.symbol": { - "chrome": "51", - "opera": "38", - "edge": "79", - "firefox": "51", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es7.symbol.async-iterator": { - "chrome": "63", - "opera": "50", - "edge": "79", - "firefox": "57", - "safari": "12", - "node": "10", - "ios": "12", - "samsung": "8", - "electron": "3.0" - }, - "es6.string.anchor": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.big": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.blink": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.bold": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.code-point-at": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "29", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.ends-with": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "29", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.fixed": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.fontcolor": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.fontsize": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.from-code-point": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "29", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.includes": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "40", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.italics": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.iterator": { - "chrome": "38", - "opera": "25", - "edge": "12", - "firefox": "36", - "safari": "9", - "node": "0.12", - "ios": "9", - "samsung": "3", - "electron": "0.20" - }, - "es6.string.link": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es7.string.pad-start": { - "chrome": "57", - "opera": "44", - "edge": "15", - "firefox": "48", - "safari": "10", - "node": "8", - "ios": "10", - "samsung": "7", - "electron": "1.7" - }, - "es7.string.pad-end": { - "chrome": "57", - "opera": "44", - "edge": "15", - "firefox": "48", - "safari": "10", - "node": "8", - "ios": "10", - "samsung": "7", - "electron": "1.7" - }, - "es6.string.raw": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "34", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.repeat": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "24", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.small": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.starts-with": { - "chrome": "41", - "opera": "28", - "edge": "12", - "firefox": "29", - "safari": "9", - "node": "4", - "ios": "9", - "samsung": "3.4", - "electron": "0.21" - }, - "es6.string.strike": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.sub": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.sup": { - "chrome": "5", - "opera": "15", - "edge": "12", - "firefox": "17", - "safari": "6", - "node": "0.10", - "android": "4", - "ios": "7", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.string.trim": { - "chrome": "5", - "opera": "10.50", - "edge": "12", - "firefox": "3.5", - "safari": "4", - "node": "0.10", - "ie": "9", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es7.string.trim-left": { - "chrome": "66", - "opera": "53", - "edge": "79", - "firefox": "61", - "safari": "12", - "node": "10", - "ios": "12", - "samsung": "9", - "electron": "3.0" - }, - "es7.string.trim-right": { - "chrome": "66", - "opera": "53", - "edge": "79", - "firefox": "61", - "safari": "12", - "node": "10", - "ios": "12", - "samsung": "9", - "electron": "3.0" - }, - "es6.typed.array-buffer": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.data-view": { - "chrome": "5", - "opera": "12", - "edge": "12", - "firefox": "15", - "safari": "5.1", - "node": "0.10", - "ie": "10", - "android": "4", - "ios": "6", - "phantom": "2", - "samsung": "1", - "electron": "0.20" - }, - "es6.typed.int8-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.uint8-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.uint8-clamped-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.int16-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.uint16-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.int32-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.uint32-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.float32-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.typed.float64-array": { - "chrome": "51", - "opera": "38", - "edge": "13", - "firefox": "48", - "safari": "10", - "node": "6.5", - "ios": "10", - "samsung": "5", - "electron": "1.2" - }, - "es6.weak-map": { - "chrome": "51", - "opera": "38", - "edge": "15", - "firefox": "53", - "safari": "9", - "node": "6.5", - "ios": "9", - "samsung": "5", - "electron": "1.2" - }, - "es6.weak-set": { - "chrome": "51", - "opera": "38", - "edge": "15", - "firefox": "53", - "safari": "9", - "node": "6.5", - "ios": "9", - "samsung": "5", - "electron": "1.2" - } -} diff --git a/packages/babel-compat-data/package.json b/packages/babel-compat-data/package.json index 3b2fdd9dee68..35b9b177fa31 100644 --- a/packages/babel-compat-data/package.json +++ b/packages/babel-compat-data/package.json @@ -15,7 +15,6 @@ "exports": { "./plugins": "./data/plugins.json", "./native-modules": "./data/native-modules.json", - "./corejs2-built-ins": "./data/corejs2-built-ins.json", "./corejs3-shipped-proposals": "./data/corejs3-shipped-proposals.json", "./overlapping-plugins": "./data/overlapping-plugins.json", "./plugin-bugfixes": "./data/plugin-bugfixes.json" diff --git a/packages/babel-compat-data/scripts/build-data.js b/packages/babel-compat-data/scripts/build-data.js index 8e97a7948b99..069b61eac85c 100644 --- a/packages/babel-compat-data/scripts/build-data.js +++ b/packages/babel-compat-data/scripts/build-data.js @@ -5,25 +5,18 @@ const compatData = require("mdn-browser-compat-data").javascript; const { process } = require("./build-modules-support"); const { generateData, environments, writeFile } = require("./utils-build-data"); -for (const target of ["plugin", "corejs2-built-in"]) { - const newData = generateData( - environments, - require(`./data/${target}-features`) - ); - if (target === "plugin") { - // add export-namespace-from from mdn-browser-compat-data - const exportNamespaceFromCompatData = process( - compatData.statements.export.namespace - ); - // the node.js compat data is 12.0, the first node version ships `export *` behind a flag - // here we overwrite to 13.2 which is the first unflagged version - exportNamespaceFromCompatData.node = "13.2"; - newData["proposal-export-namespace-from"] = exportNamespaceFromCompatData; - } - const dataPath = path.join(__dirname, `../data/${target}s.json`); +const newData = generateData(environments, require("./data/plugin-features")); +// add export-namespace-from from mdn-browser-compat-data +const exportNamespaceFromCompatData = process( + compatData.statements.export.namespace +); +// the node.js compat data is 12.0, the first node version ships `export *` behind a flag +// here we overwrite to 13.2 which is the first unflagged version +exportNamespaceFromCompatData.node = "13.2"; +newData["proposal-export-namespace-from"] = exportNamespaceFromCompatData; - if (!writeFile(newData, dataPath, target)) { - process.exitCode = 1; - break; - } +const dataPath = path.join(__dirname, "../data/plugins.json"); + +if (!writeFile(newData, dataPath, "plugin")) { + process.exitCode = 1; } diff --git a/packages/babel-compat-data/scripts/data/corejs2-built-in-features.js b/packages/babel-compat-data/scripts/data/corejs2-built-in-features.js deleted file mode 100644 index 2beb9bbed4c8..000000000000 --- a/packages/babel-compat-data/scripts/data/corejs2-built-in-features.js +++ /dev/null @@ -1,378 +0,0 @@ -const typedArrayMethods = [ - "typed arrays / %TypedArray%.from", - "typed arrays / %TypedArray%.of", - "typed arrays / %TypedArray%.prototype.subarray", - "typed arrays / %TypedArray%.prototype.join", - "typed arrays / %TypedArray%.prototype.indexOf", - "typed arrays / %TypedArray%.prototype.lastIndexOf", - "typed arrays / %TypedArray%.prototype.slice", - "typed arrays / %TypedArray%.prototype.every", - "typed arrays / %TypedArray%.prototype.filter", - "typed arrays / %TypedArray%.prototype.forEach", - "typed arrays / %TypedArray%.prototype.map", - "typed arrays / %TypedArray%.prototype.reduce", - "typed arrays / %TypedArray%.prototype.reduceRight", - "typed arrays / %TypedArray%.prototype.reverse", - "typed arrays / %TypedArray%.prototype.some", - "typed arrays / %TypedArray%.prototype.sort", - "typed arrays / %TypedArray%.prototype.copyWithin", - "typed arrays / %TypedArray%.prototype.find", - "typed arrays / %TypedArray%.prototype.findIndex", - "typed arrays / %TypedArray%.prototype.fill", - "typed arrays / %TypedArray%.prototype.keys", - "typed arrays / %TypedArray%.prototype.values", - "typed arrays / %TypedArray%.prototype.entries", - "typed arrays / %TypedArray%.prototype[Symbol.iterator]", - "typed arrays / %TypedArray%[Symbol.species]", -]; - -module.exports = { - // compat-table missing babel6 mapping - // "es6.array.concat": { - // features: [ - // "well-known symbols / Symbol.isConcatSpreadable", - // "well-known symbols / Symbol.species, Array.prototype.concat", - // ] - // }, - "es6.array.copy-within": - "Array.prototype methods / Array.prototype.copyWithin", - "es6.array.every": "Array methods / Array.prototype.every", - "es6.array.fill": "Array.prototype methods / Array.prototype.fill", - "es6.array.filter": { - features: [ - "Array methods / Array.prototype.filter", - // compat-table missing babel6 mapping - // "well-known symbols / Symbol.species, Array.prototype.filter", - ], - }, - "es6.array.find": "Array.prototype methods / Array.prototype.find", - "es6.array.find-index": "Array.prototype methods / Array.prototype.findIndex", - "es7.array.flat-map": - "Array.prototype.{flat, flatMap} / Array.prototype.flatMap", - "es6.array.for-each": "Array methods / Array.prototype.forEach", - "es6.array.from": "Array static methods / Array.from", - "es7.array.includes": "Array.prototype.includes", - "es6.array.index-of": "Array methods / Array.prototype.indexOf", - "es6.array.is-array": "Array methods / Array.isArray", - // "es.array.join": "", required tests for that - "es6.array.iterator": { - features: [ - "Array.prototype methods / Array.prototype.keys", - // can use Symbol.iterator, not implemented in many environments - // "Array.prototype methods / Array.prototype.values", - "Array.prototype methods / Array.prototype.entries", - ], - }, - "es6.array.last-index-of": "Array methods / Array.prototype.lastIndexOf", - "es6.array.map": { - features: [ - "Array methods / Array.prototype.map", - // compat-table missing babel6 mapping - // "well-known symbols / Symbol.species, Array.prototype.map", - ], - }, - "es6.array.of": "Array static methods / Array.of", - "es6.array.reduce": "Array methods / Array.prototype.reduce", - "es6.array.reduce-right": "Array methods / Array.prototype.reduceRight", - // compat-table missing babel6 mapping - // "es6.array.slice": "well-known symbols / Symbol.species, Array.prototype.slice", - "es6.array.some": "Array methods / Array.prototype.some", - "es6.array.sort": "Array methods / Array.prototype.sort", - "es6.array.species": "Array static methods / Array[Symbol.species]", - // compat-table missing babel6 mapping - //"es6.array.splice": "well-known symbols / Symbol.species, Array.prototype.splice", - - "es6.date.now": "Date methods / Date.now", - "es6.date.to-iso-string": "Date methods / Date.prototype.toISOString", - "es6.date.to-json": "Date methods / Date.prototype.toJSON", - "es6.date.to-primitive": "Date.prototype[Symbol.toPrimitive]", - "es6.date.to-string": "miscellaneous / Invalid Date", - - "es6.function.bind": "Function.prototype.bind", - "es6.function.has-instance": "well-known symbols / Symbol.hasInstance", - "es6.function.name": { - features: [ - 'function "name" property / function statements', - 'function "name" property / function expressions', - ], - }, - - // This is explicit to prevent Map-related proposals (like - // Map.prototype.upsert) from being included - "es6.map": { - features: [ - "Map / basic functionality", - "Map / constructor arguments", - "Map / constructor requires new", - "Map / constructor accepts null", - "Map / constructor invokes set", - "Map / iterator closing", - "Map / Map.prototype.add returns this", - "Map / -0 key converts to +0", - "Map / Map.prototype.size", - "Map / Map.prototype.delete", - "Map / Map.prototype.clear", - "Map / Map.prototype.forEach", - "Map / Map.prototype.keys", - "Map / Map.prototype.values", - "Map / Map.prototype.entries", - "Map / Map.prototype[Symbol.iterator]", - "Map / Map.prototype isn't an instance", - "Map / Map iterator prototype chain", - "Map / Map[Symbol.species]", - ], - }, - - "es6.math.acosh": "Math methods / Math.acosh", - "es6.math.asinh": "Math methods / Math.asinh", - "es6.math.atanh": "Math methods / Math.atanh", - "es6.math.cbrt": "Math methods / Math.cbrt", - "es6.math.clz32": "Math methods / Math.clz32", - "es6.math.cosh": "Math methods / Math.cosh", - "es6.math.expm1": "Math methods / Math.expm1", - "es6.math.fround": "Math methods / Math.fround", - "es6.math.hypot": "Math methods / Math.hypot", - "es6.math.imul": "Math methods / Math.imul", - "es6.math.log1p": "Math methods / Math.log1p", - "es6.math.log10": "Math methods / Math.log10", - "es6.math.log2": "Math methods / Math.log2", - "es6.math.sign": "Math methods / Math.sign", - "es6.math.sinh": "Math methods / Math.sinh", - "es6.math.tanh": "Math methods / Math.tanh", - "es6.math.trunc": "Math methods / Math.trunc", - - "es6.number.constructor": { - features: [ - "octal and binary literals / octal supported by Number()", - "octal and binary literals / binary supported by Number()", - ], - }, - "es6.number.epsilon": "Number properties / Number.EPSILON", - "es6.number.is-finite": "Number properties / Number.isFinite", - "es6.number.is-integer": "Number properties / Number.isInteger", - "es6.number.is-nan": "Number properties / Number.isNaN", - "es6.number.is-safe-integer": "Number properties / Number.isSafeInteger", - "es6.number.max-safe-integer": "Number properties / Number.MAX_SAFE_INTEGER", - "es6.number.min-safe-integer": "Number properties / Number.MIN_SAFE_INTEGER", - "es6.number.parse-float": "Number properties / Number.parseFloat", - "es6.number.parse-int": "Number properties / Number.parseInt", - - "es6.object.assign": { - features: ["Object static methods / Object.assign", "Symbol"], - }, - "es6.object.create": "Object static methods / Object.create", - "es7.object.define-getter": { - features: [ - "Object.prototype getter/setter methods / __defineGetter__", - "Object.prototype getter/setter methods / __defineGetter__, symbols", - "Object.prototype getter/setter methods / __defineGetter__, ToObject(this)", - ], - }, - "es7.object.define-setter": { - features: [ - "Object.prototype getter/setter methods / __defineSetter__", - "Object.prototype getter/setter methods / __defineSetter__, symbols", - "Object.prototype getter/setter methods / __defineSetter__, ToObject(this)", - ], - }, - "es6.object.define-property": "Object static methods / Object.defineProperty", - "es6.object.define-properties": - "Object static methods / Object.defineProperties", - "es7.object.entries": "Object static methods / Object.entries", - "es6.object.freeze": - "Object static methods accept primitives / Object.freeze", - "es6.object.get-own-property-descriptor": - "Object static methods accept primitives / Object.getOwnPropertyDescriptor", - "es7.object.get-own-property-descriptors": - "Object static methods / Object.getOwnPropertyDescriptors", - "es6.object.get-own-property-names": - "Object static methods accept primitives / Object.getOwnPropertyNames", - "es6.object.get-prototype-of": - "Object static methods accept primitives / Object.getPrototypeOf", - "es7.object.lookup-getter": { - features: [ - "Object.prototype getter/setter methods / __lookupGetter__", - "Object.prototype getter/setter methods / __lookupGetter__, prototype chain", - "Object.prototype getter/setter methods / __lookupGetter__, symbols", - "Object.prototype getter/setter methods / __lookupGetter__, ToObject(this)", - "Object.prototype getter/setter methods / __lookupGetter__, data properties can shadow accessors", - ], - }, - "es7.object.lookup-setter": { - features: [ - "Object.prototype getter/setter methods / __lookupSetter__", - "Object.prototype getter/setter methods / __lookupSetter__, prototype chain", - "Object.prototype getter/setter methods / __lookupSetter__, symbols", - "Object.prototype getter/setter methods / __lookupSetter__, ToObject(this)", - "Object.prototype getter/setter methods / __lookupSetter__, data properties can shadow accessors", - ], - }, - "es6.object.prevent-extensions": - "Object static methods accept primitives / Object.preventExtensions", - "es6.object.to-string": "well-known symbols / Symbol.toStringTag", - "es6.object.is": "Object static methods / Object.is", - "es6.object.is-frozen": - "Object static methods accept primitives / Object.isFrozen", - "es6.object.is-sealed": - "Object static methods accept primitives / Object.isSealed", - "es6.object.is-extensible": - "Object static methods accept primitives / Object.isExtensible", - "es6.object.keys": "Object static methods accept primitives / Object.keys", - "es6.object.seal": "Object static methods accept primitives / Object.seal", - "es6.object.set-prototype-of": - "Object static methods / Object.setPrototypeOf", - "es7.object.values": "Object static methods / Object.values", - - "es6.promise": { - features: [ - // required unhandled rejection tracking tests - "Promise", - "well-known symbols / Symbol.species, Promise.prototype.then", - ], - }, - "es7.promise.finally": "Promise.prototype.finally", - - "es6.reflect.apply": "Reflect / Reflect.apply", - "es6.reflect.construct": "Reflect / Reflect.construct", - "es6.reflect.define-property": "Reflect / Reflect.defineProperty", - "es6.reflect.delete-property": "Reflect / Reflect.deleteProperty", - "es6.reflect.get": "Reflect / Reflect.get", - "es6.reflect.get-own-property-descriptor": - "Reflect / Reflect.getOwnPropertyDescriptor", - "es6.reflect.get-prototype-of": "Reflect / Reflect.getPrototypeOf", - "es6.reflect.has": "Reflect / Reflect.has", - "es6.reflect.is-extensible": "Reflect / Reflect.isExtensible", - "es6.reflect.own-keys": "Reflect / Reflect.ownKeys", - "es6.reflect.prevent-extensions": "Reflect / Reflect.preventExtensions", - "es6.reflect.set": "Reflect / Reflect.set", - "es6.reflect.set-prototype-of": "Reflect / Reflect.setPrototypeOf", - - "es6.regexp.constructor": { - features: [ - "miscellaneous / RegExp constructor can alter flags", - "well-known symbols / Symbol.match, RegExp constructor", - ], - }, - "es6.regexp.flags": "RegExp.prototype properties / RegExp.prototype.flags", - "es6.regexp.match": - "RegExp.prototype properties / RegExp.prototype[Symbol.match]", - "es6.regexp.replace": - "RegExp.prototype properties / RegExp.prototype[Symbol.replace]", - "es6.regexp.split": - "RegExp.prototype properties / RegExp.prototype[Symbol.split]", - "es6.regexp.search": - "RegExp.prototype properties / RegExp.prototype[Symbol.search]", - "es6.regexp.to-string": - 'miscellaneous / RegExp.prototype.toString generic and uses "flags" property', - - // This is explicit due to prevent the stage-1 Set proposals under the - // category "Set methods" from being included. - "es6.set": { - features: [ - "Set / basic functionality", - "Set / constructor arguments", - "Set / constructor requires new", - "Set / constructor accepts null", - "Set / constructor invokes add", - "Set / iterator closing", - "Set / Set.prototype.add returns this", - "Set / -0 key converts to +0", - "Set / Set.prototype.size", - "Set / Set.prototype.delete", - "Set / Set.prototype.clear", - "Set / Set.prototype.forEach", - "Set / Set.prototype.keys", - "Set / Set.prototype.values", - "Set / Set.prototype.entries", - "Set / Set.prototype[Symbol.iterator]", - "Set / Set.prototype isn't an instance", - "Set / Set iterator prototype chain", - "Set / Set[Symbol.species]", - ], - }, - - "es6.symbol": { - features: [ - "Symbol", - "Object static methods / Object.getOwnPropertySymbols", - "well-known symbols / Symbol.hasInstance", - "well-known symbols / Symbol.isConcatSpreadable", - "well-known symbols / Symbol.iterator", - "well-known symbols / Symbol.match", - "well-known symbols / Symbol.replace", - "well-known symbols / Symbol.search", - "well-known symbols / Symbol.species", - "well-known symbols / Symbol.split", - "well-known symbols / Symbol.toPrimitive", - "well-known symbols / Symbol.toStringTag", - "well-known symbols / Symbol.unscopables", - ], - }, - "es7.symbol.async-iterator": "Asynchronous Iterators", - - "es6.string.anchor": "String.prototype HTML methods", - "es6.string.big": "String.prototype HTML methods", - "es6.string.blink": "String.prototype HTML methods", - "es6.string.bold": "String.prototype HTML methods", - "es6.string.code-point-at": - "String.prototype methods / String.prototype.codePointAt", - "es6.string.ends-with": - "String.prototype methods / String.prototype.endsWith", - "es6.string.fixed": "String.prototype HTML methods", - "es6.string.fontcolor": "String.prototype HTML methods", - "es6.string.fontsize": "String.prototype HTML methods", - "es6.string.from-code-point": "String static methods / String.fromCodePoint", - "es6.string.includes": "String.prototype methods / String.prototype.includes", - "es6.string.italics": "String.prototype HTML methods", - "es6.string.iterator": - "String.prototype methods / String.prototype[Symbol.iterator]", - "es6.string.link": "String.prototype HTML methods", - // "String.prototype methods / String.prototype.normalize" not implemented - "es7.string.pad-start": "String padding / String.prototype.padStart", - "es7.string.pad-end": "String padding / String.prototype.padEnd", - "es6.string.raw": "String static methods / String.raw", - "es6.string.repeat": "String.prototype methods / String.prototype.repeat", - "es6.string.small": "String.prototype HTML methods", - "es6.string.starts-with": - "String.prototype methods / String.prototype.startsWith", - "es6.string.strike": "String.prototype HTML methods", - "es6.string.sub": "String.prototype HTML methods", - "es6.string.sup": "String.prototype HTML methods", - "es6.string.trim": "String properties and methods / String.prototype.trim", - "es7.string.trim-left": "string trimming / String.prototype.trimStart", - "es7.string.trim-right": "string trimming / String.prototype.trimEnd", - - "es6.typed.array-buffer": "typed arrays / ArrayBuffer[Symbol.species]", - "es6.typed.data-view": "typed arrays / DataView", - "es6.typed.int8-array": { - features: ["typed arrays / Int8Array"].concat(typedArrayMethods), - }, - "es6.typed.uint8-array": { - features: ["typed arrays / Uint8Array"].concat(typedArrayMethods), - }, - "es6.typed.uint8-clamped-array": { - features: ["typed arrays / Uint8ClampedArray"].concat(typedArrayMethods), - }, - "es6.typed.int16-array": { - features: ["typed arrays / Int16Array"].concat(typedArrayMethods), - }, - "es6.typed.uint16-array": { - features: ["typed arrays / Uint16Array"].concat(typedArrayMethods), - }, - "es6.typed.int32-array": { - features: ["typed arrays / Int32Array"].concat(typedArrayMethods), - }, - "es6.typed.uint32-array": { - features: ["typed arrays / Uint32Array"].concat(typedArrayMethods), - }, - "es6.typed.float32-array": { - features: ["typed arrays / Float32Array"].concat(typedArrayMethods), - }, - "es6.typed.float64-array": { - features: ["typed arrays / Float64Array"].concat(typedArrayMethods), - }, - - "es6.weak-map": "WeakMap", - - "es6.weak-set": "WeakSet", -}; diff --git a/packages/babel-core/package.json b/packages/babel-core/package.json index b55ba4d29c28..c9ce98dcbf16 100644 --- a/packages/babel-core/package.json +++ b/packages/babel-core/package.json @@ -30,7 +30,7 @@ "compiler" ], "engines": { - "node": ">=6.9.0" + "node": ">=10.13.0" }, "funding": { "type": "opencollective", @@ -53,10 +53,10 @@ "@babel/types": "workspace:^7.12.1", "convert-source-map": "^1.7.0", "debug": "^4.1.0", + "escape-string-regexp": "^4.0.0", "gensync": "^1.0.0-beta.1", "json5": "^2.1.2", "lodash": "^4.17.19", - "resolve": "^1.3.2", "semver": "^5.4.1", "source-map": "^0.5.0" }, diff --git a/packages/babel-core/src/config/files/configuration.js b/packages/babel-core/src/config/files/configuration.js index 3107786cf3d8..8a3bed914fab 100644 --- a/packages/babel-core/src/config/files/configuration.js +++ b/packages/babel-core/src/config/files/configuration.js @@ -17,7 +17,6 @@ import type { FilePackageData, RelativeConfig, ConfigFile } from "./types"; import type { CallerMetadata } from "../validation/options"; import * as fs from "../../gensync-utils/fs"; -import resolve from "../../gensync-utils/resolve"; const debug = buildDebug("babel:config:loading:files:configuration"); @@ -136,7 +135,7 @@ export function* loadConfig( envName: string, caller: CallerMetadata | void, ): Handler { - const filepath = yield* resolve(name, { basedir: dirname }); + const filepath = require.resolve(name, { paths: [dirname] }); const conf = yield* readConfig(filepath, envName, caller); if (!conf) { diff --git a/packages/babel-core/src/config/files/plugins.js b/packages/babel-core/src/config/files/plugins.js index 47cfa8645003..298843e2d609 100644 --- a/packages/babel-core/src/config/files/plugins.js +++ b/packages/babel-core/src/config/files/plugins.js @@ -5,7 +5,6 @@ */ import buildDebug from "debug"; -import resolve from "resolve"; import path from "path"; const debug = buildDebug("babel:config:loading:files:plugins"); @@ -96,14 +95,18 @@ function resolveStandardizedName( const standardizedName = standardizeName(type, name); try { - return resolve.sync(standardizedName, { basedir: dirname }); + return require.resolve(standardizedName, { + paths: [dirname], + }); } catch (e) { if (e.code !== "MODULE_NOT_FOUND") throw e; if (standardizedName !== name) { let resolvedOriginal = false; try { - resolve.sync(name, { basedir: dirname }); + require.resolve(name, { + paths: [dirname], + }); resolvedOriginal = true; } catch {} @@ -114,8 +117,8 @@ function resolveStandardizedName( let resolvedBabel = false; try { - resolve.sync(standardizeName(type, "@babel/" + name), { - basedir: dirname, + require.resolve(standardizeName(type, "@babel/" + name), { + paths: [dirname], }); resolvedBabel = true; } catch {} @@ -127,7 +130,9 @@ function resolveStandardizedName( let resolvedOppositeType = false; const oppositeType = type === "preset" ? "plugin" : "preset"; try { - resolve.sync(standardizeName(oppositeType, name), { basedir: dirname }); + require.resolve(standardizeName(oppositeType, name), { + paths: [dirname], + }); resolvedOppositeType = true; } catch {} diff --git a/packages/babel-core/src/config/full.js b/packages/babel-core/src/config/full.js index 75fbe293c7c9..fae0eec22045 100644 --- a/packages/babel-core/src/config/full.js +++ b/packages/babel-core/src/config/full.js @@ -327,11 +327,17 @@ const instantiatePlugin = makeWeakCache(function* ( return new Plugin(plugin, options, alias); }); +const needsFilename = val => val && typeof val !== "function"; + const validateIfOptionNeedsFilename = ( options: ValidatedOptions, descriptor: UnloadedDescriptor, ): void => { - if (options.test || options.include || options.exclude) { + if ( + needsFilename(options.test) || + needsFilename(options.include) || + needsFilename(options.exclude) + ) { const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */"; diff --git a/packages/babel-core/src/config/pattern-to-regex.js b/packages/babel-core/src/config/pattern-to-regex.js index d796617f89b4..7a627bb06436 100644 --- a/packages/babel-core/src/config/pattern-to-regex.js +++ b/packages/babel-core/src/config/pattern-to-regex.js @@ -1,6 +1,6 @@ // @flow import path from "path"; -import escapeRegExp from "lodash/escapeRegExp"; +import escapeRegExp from "escape-string-regexp"; const sep = `\\${path.sep}`; const endSep = `(?:${sep}|$)`; diff --git a/packages/babel-core/src/gensync-utils/resolve.js b/packages/babel-core/src/gensync-utils/resolve.js deleted file mode 100644 index d16f6e7c4b2c..000000000000 --- a/packages/babel-core/src/gensync-utils/resolve.js +++ /dev/null @@ -1,9 +0,0 @@ -// @flow - -import resolve from "resolve"; -import gensync from "gensync"; - -export default gensync<[string, {| basedir: string |}], string>({ - sync: resolve.sync, - errback: resolve, -}); diff --git a/packages/babel-core/src/parser/util/missing-plugin-helper.js b/packages/babel-core/src/parser/util/missing-plugin-helper.js index b1a949746d51..40da224a6ed1 100644 --- a/packages/babel-core/src/parser/util/missing-plugin-helper.js +++ b/packages/babel-core/src/parser/util/missing-plugin-helper.js @@ -67,12 +67,6 @@ const pluginNameMap = { url: "https://git.io/vb4S3", }, }, - dynamicImport: { - syntax: { - name: "@babel/plugin-syntax-dynamic-import", - url: "https://git.io/vb4Sv", - }, - }, exportDefaultFrom: { syntax: { name: "@babel/plugin-syntax-export-default-from", @@ -83,16 +77,6 @@ const pluginNameMap = { url: "https://git.io/vb4yH", }, }, - exportNamespaceFrom: { - syntax: { - name: "@babel/plugin-syntax-export-namespace-from", - url: "https://git.io/vb4Sf", - }, - transform: { - name: "@babel/plugin-proposal-export-namespace-from", - url: "https://git.io/vb4SG", - }, - }, flow: { syntax: { name: "@babel/plugin-syntax-flow", @@ -161,16 +145,6 @@ const pluginNameMap = { url: "https://git.io/vb4yS", }, }, - optionalChaining: { - syntax: { - name: "@babel/plugin-syntax-optional-chaining", - url: "https://git.io/vb4Sc", - }, - transform: { - name: "@babel/plugin-proposal-optional-chaining", - url: "https://git.io/vb4Sk", - }, - }, pipelineOperator: { syntax: { name: "@babel/plugin-syntax-pipeline-operator", @@ -218,60 +192,10 @@ const pluginNameMap = { }, }, - // TODO: This plugins are now supported by default by @babel/parser: they can + // TODO: These plugins are now supported by default by @babel/parser: they can // be removed from this list. Although removing them isn't a breaking change, // it's better to keep a nice error message for users using older versions of - // the parser. They can be removed in Babel 8. - asyncGenerators: { - syntax: { - name: "@babel/plugin-syntax-async-generators", - url: "https://git.io/vb4SY", - }, - transform: { - name: "@babel/plugin-proposal-async-generator-functions", - url: "https://git.io/vb4yp", - }, - }, - logicalAssignment: { - syntax: { - name: "@babel/plugin-syntax-logical-assignment-operators", - url: "https://git.io/vAlBp", - }, - transform: { - name: "@babel/plugin-proposal-logical-assignment-operators", - url: "https://git.io/vAlRe", - }, - }, - nullishCoalescingOperator: { - syntax: { - name: "@babel/plugin-syntax-nullish-coalescing-operator", - url: "https://git.io/vb4yx", - }, - transform: { - name: "@babel/plugin-proposal-nullish-coalescing-operator", - url: "https://git.io/vb4Se", - }, - }, - objectRestSpread: { - syntax: { - name: "@babel/plugin-syntax-object-rest-spread", - url: "https://git.io/vb4y5", - }, - transform: { - name: "@babel/plugin-proposal-object-rest-spread", - url: "https://git.io/vb4Ss", - }, - }, - optionalCatchBinding: { - syntax: { - name: "@babel/plugin-syntax-optional-catch-binding", - url: "https://git.io/vb4Sn", - }, - transform: { - name: "@babel/plugin-proposal-optional-catch-binding", - url: "https://git.io/vb4SI", - }, - }, + // the parser. They can be removed in Babel 9. }; //todo: we don't have plugin-syntax-private-property-in-object diff --git a/packages/babel-core/test/api.js b/packages/babel-core/test/api.js index bf714bc6e9f5..9e04d85a623a 100644 --- a/packages/babel-core/test/api.js +++ b/packages/babel-core/test/api.js @@ -144,13 +144,13 @@ describe("parser and generator options", function () { describe("api", function () { it("exposes the resolvePlugin method", function () { expect(() => babel.resolvePlugin("nonexistent-plugin")).toThrow( - /Cannot find module 'babel-plugin-nonexistent-plugin'/, + /Cannot resolve module 'babel-plugin-nonexistent-plugin'/, ); }); it("exposes the resolvePreset method", function () { expect(() => babel.resolvePreset("nonexistent-preset")).toThrow( - /Cannot find module 'babel-preset-nonexistent-preset'/, + /Cannot resolve module 'babel-preset-nonexistent-preset'/, ); }); diff --git a/packages/babel-core/test/async.js b/packages/babel-core/test/async.js index 0e2bbdce8c02..2a02efbc4e8d 100644 --- a/packages/babel-core/test/async.js +++ b/packages/babel-core/test/async.js @@ -1,12 +1,6 @@ import path from "path"; import * as babel from ".."; -const nodeGte8 = (...args) => { - // "minNodeVersion": "8.0.0" <-- For Ctrl+F when dropping node 6 - const testFn = process.version.slice(0, 3) === "v6." ? it.skip : it; - testFn(...args); -}; - describe("asynchronicity", () => { const base = path.join(__dirname, "fixtures", "async"); let cwd; @@ -22,7 +16,7 @@ describe("asynchronicity", () => { describe("config file", () => { describe("async function", () => { - nodeGte8("called synchronously", () => { + it("called synchronously", () => { process.chdir("config-file-async-function"); expect(() => @@ -35,7 +29,7 @@ describe("asynchronicity", () => { ); }); - nodeGte8("called asynchronously", async () => { + it("called asynchronously", async () => { process.chdir("config-file-async-function"); await expect( @@ -78,7 +72,7 @@ describe("asynchronicity", () => { }); describe("cache.using", () => { - nodeGte8("called synchronously", () => { + it("called synchronously", () => { process.chdir("config-cache"); expect(() => @@ -91,7 +85,7 @@ describe("asynchronicity", () => { ); }); - nodeGte8("called asynchronously", async () => { + it("called asynchronously", async () => { process.chdir("config-cache"); await expect( @@ -108,7 +102,7 @@ describe("asynchronicity", () => { describe("plugin", () => { describe("factory function", () => { - nodeGte8("called synchronously", () => { + it("called synchronously", () => { process.chdir("plugin"); expect(() => @@ -120,7 +114,7 @@ describe("asynchronicity", () => { ); }); - nodeGte8("called asynchronously", async () => { + it("called asynchronously", async () => { process.chdir("plugin"); await expect( @@ -134,7 +128,7 @@ describe("asynchronicity", () => { }); describe(".pre", () => { - nodeGte8("called synchronously", () => { + it("called synchronously", () => { process.chdir("plugin-pre"); expect(() => @@ -146,7 +140,7 @@ describe("asynchronicity", () => { ); }); - nodeGte8("called asynchronously", async () => { + it("called asynchronously", async () => { process.chdir("plugin-pre"); await expect( @@ -160,7 +154,7 @@ describe("asynchronicity", () => { }); describe(".post", () => { - nodeGte8("called synchronously", () => { + it("called synchronously", () => { process.chdir("plugin-post"); expect(() => @@ -172,7 +166,7 @@ describe("asynchronicity", () => { ); }); - nodeGte8("called asynchronously", async () => { + it("called asynchronously", async () => { process.chdir("plugin-post"); await expect( @@ -186,7 +180,7 @@ describe("asynchronicity", () => { }); describe("inherits", () => { - nodeGte8("called synchronously", () => { + it("called synchronously", () => { process.chdir("plugin-inherits"); expect(() => @@ -198,7 +192,7 @@ describe("asynchronicity", () => { ); }); - nodeGte8("called asynchronously", async () => { + it("called asynchronously", async () => { process.chdir("plugin-inherits"); await expect( diff --git a/packages/babel-core/test/config-chain.js b/packages/babel-core/test/config-chain.js index 167dc1e3bb91..97ca594e524a 100644 --- a/packages/babel-core/test/config-chain.js +++ b/packages/babel-core/test/config-chain.js @@ -6,40 +6,7 @@ import util from "util"; import escapeRegExp from "lodash/escapeRegExp"; import * as babel from "../lib"; -// TODO: In Babel 8, we can directly uses fs.promises which is supported by -// node 8+ -const pfs = - fs.promises ?? - new Proxy(fs, { - get(target, name) { - if (name === "copyFile") { - // fs.copyFile is only supported since node 8.5 - // https://stackoverflow.com/a/30405105/2359289 - return function copyFile(source, target) { - const rd = fs.createReadStream(source); - const wr = fs.createWriteStream(target); - return new Promise(function (resolve, reject) { - rd.on("error", reject); - wr.on("error", reject); - wr.on("finish", resolve); - rd.pipe(wr); - }).catch(function (error) { - rd.destroy(); - wr.end(); - throw error; - }); - }; - } - - return (...args) => - new Promise((resolve, reject) => - target[name](...args, (error, result) => { - if (error) reject(error); - else resolve(result); - }), - ); - }, - }); +const pfs = fs.promises; function fixture(...args) { return path.join(__dirname, "fixtures", "config", ...args); diff --git a/packages/babel-core/test/resolution.js b/packages/babel-core/test/resolution.js index 7ec7a628ef24..aa0db96736f8 100644 --- a/packages/babel-core/test/resolution.js +++ b/packages/babel-core/test/resolution.js @@ -344,7 +344,7 @@ describe("addon resolution", function () { presets: ["foo"], }); }).toThrow( - /Cannot find module 'babel-preset-foo'.*\n- If you want to resolve "foo", use "module:foo"/, + /Cannot resolve module 'babel-preset-foo'.*\n- If you want to resolve "foo", use "module:foo"/, ); }); @@ -358,7 +358,7 @@ describe("addon resolution", function () { plugins: ["foo"], }); }).toThrow( - /Cannot find module 'babel-plugin-foo'.*\n- If you want to resolve "foo", use "module:foo"/, + /Cannot resolve module 'babel-plugin-foo'.*\n- If you want to resolve "foo", use "module:foo"/, ); }); @@ -372,7 +372,7 @@ describe("addon resolution", function () { presets: ["foo"], }); }).toThrow( - /Cannot find module 'babel-preset-foo'.*\n- Did you mean "@babel\/foo"\?/, + /Cannot resolve module 'babel-preset-foo'.*\n- Did you mean "@babel\/foo"\?/, ); }); @@ -386,7 +386,7 @@ describe("addon resolution", function () { plugins: ["foo"], }); }).toThrow( - /Cannot find module 'babel-plugin-foo'.*\n- Did you mean "@babel\/foo"\?/, + /Cannot resolve module 'babel-plugin-foo'.*\n- Did you mean "@babel\/foo"\?/, ); }); @@ -400,7 +400,7 @@ describe("addon resolution", function () { presets: ["testplugin"], }); }).toThrow( - /Cannot find module 'babel-preset-testplugin'.*\n- Did you accidentally pass a plugin as a preset\?/, + /Cannot resolve module 'babel-preset-testplugin'.*\n- Did you accidentally pass a plugin as a preset\?/, ); }); @@ -414,7 +414,7 @@ describe("addon resolution", function () { plugins: ["testpreset"], }); }).toThrow( - /Cannot find module 'babel-plugin-testpreset'.*\n- Did you accidentally pass a preset as a plugin\?/, + /Cannot resolve module 'babel-plugin-testpreset'.*\n- Did you accidentally pass a preset as a plugin\?/, ); }); @@ -427,7 +427,7 @@ describe("addon resolution", function () { babelrc: false, presets: ["foo"], }); - }).toThrow(/Cannot find module 'babel-preset-foo'/); + }).toThrow(/Cannot resolve module 'babel-preset-foo'/); }); it("should throw about missing plugins", function () { @@ -439,6 +439,6 @@ describe("addon resolution", function () { babelrc: false, plugins: ["foo"], }); - }).toThrow(/Cannot find module 'babel-plugin-foo'/); + }).toThrow(/Cannot resolve module 'babel-plugin-foo'/); }); }); diff --git a/packages/babel-generator/package.json b/packages/babel-generator/package.json index 7bab3787c376..91b7a7ed4541 100644 --- a/packages/babel-generator/package.json +++ b/packages/babel-generator/package.json @@ -19,7 +19,7 @@ ], "dependencies": { "@babel/types": "workspace:^7.12.1", - "jsesc": "^2.5.1", + "jsesc": "^3.0.1", "source-map": "^0.5.0" }, "devDependencies": { diff --git a/packages/babel-generator/src/generators/types.js b/packages/babel-generator/src/generators/types.js index 0b70c7a3d976..db367938cf92 100644 --- a/packages/babel-generator/src/generators/types.js +++ b/packages/babel-generator/src/generators/types.js @@ -203,11 +203,7 @@ export function StringLiteral(node: Object) { return; } - // ensure the output is ASCII-safe const opts = this.format.jsescOption; - if (this.format.jsonCompatibleStrings) { - opts.json = true; - } const val = jsesc(node.value, opts); return this.token(val); diff --git a/packages/babel-generator/src/index.js b/packages/babel-generator/src/index.js index 176efa0255d4..bd32b40d7d89 100644 --- a/packages/babel-generator/src/index.js +++ b/packages/babel-generator/src/index.js @@ -46,7 +46,6 @@ function normalizeOptions(code, opts): Format { compact: opts.compact, minified: opts.minified, concise: opts.concise, - jsonCompatibleStrings: opts.jsonCompatibleStrings, indent: { adjustMultilineComment: true, style: " ", @@ -56,6 +55,7 @@ function normalizeOptions(code, opts): Format { jsescOption: { quotes: "double", wrap: true, + minimal: true, ...opts.jsescOption, }, recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType, diff --git a/packages/babel-generator/test/fixtures/escapes/jsonEscape/options.json b/packages/babel-generator/test/fixtures/escapes/jsonEscape/options.json index 96bc693445f1..a6a6b9d33fb5 100644 --- a/packages/babel-generator/test/fixtures/escapes/jsonEscape/options.json +++ b/packages/babel-generator/test/fixtures/escapes/jsonEscape/options.json @@ -1,4 +1,4 @@ { "minified": true, - "jsonCompatibleStrings": true + "jsescOption": { "json": true } } diff --git a/packages/babel-generator/test/fixtures/escapes/jsonEscape/output.js b/packages/babel-generator/test/fixtures/escapes/jsonEscape/output.js index 4da42cb39725..361472ec13c0 100644 --- a/packages/babel-generator/test/fixtures/escapes/jsonEscape/output.js +++ b/packages/babel-generator/test/fixtures/escapes/jsonEscape/output.js @@ -1,2 +1,2 @@ 0;// Not a directive -"\u00A9"; \ No newline at end of file +"©"; diff --git a/packages/babel-generator/test/fixtures/minified/literals/input.js b/packages/babel-generator/test/fixtures/minified/literals/input.js index 42ffdc30a312..8799ed5e7c20 100644 --- a/packages/babel-generator/test/fixtures/minified/literals/input.js +++ b/packages/babel-generator/test/fixtures/minified/literals/input.js @@ -6,6 +6,7 @@ '\x20'; "\n\r"; "😂"; +"\uD83D_\uDE02" `😂`; /foobar/g; null; diff --git a/packages/babel-generator/test/fixtures/minified/literals/output.js b/packages/babel-generator/test/fixtures/minified/literals/output.js index a44147f006b5..82fa0cfb8604 100644 --- a/packages/babel-generator/test/fixtures/minified/literals/output.js +++ b/packages/babel-generator/test/fixtures/minified/literals/output.js @@ -1 +1 @@ -5;5;50;5e4;"foobar";" ";"\n\r";"\uD83D\uDE02";`😂`;/foobar/g;null;true;false;5;2;56;31; \ No newline at end of file +5;5;50;5e4;"foobar";" ";"\n\r";"😂";"\uD83D_\uDE02"`😂`;/foobar/g;null;true;false;5;2;56;31; diff --git a/packages/babel-helper-builder-react-jsx/src/index.js b/packages/babel-helper-builder-react-jsx/src/index.js index f0bce14c76fb..adb58ec25349 100644 --- a/packages/babel-helper-builder-react-jsx/src/index.js +++ b/packages/babel-helper-builder-react-jsx/src/index.js @@ -144,7 +144,7 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`, let attribs = openingPath.node.attributes; if (attribs.length) { - attribs = buildOpeningElementAttributes(attribs, file); + attribs = buildOpeningElementAttributes(attribs); } else { attribs = t.nullLiteral(); } @@ -161,82 +161,9 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`, return call; } - function pushProps(_props, objs) { - if (!_props.length) return _props; - - objs.push(t.objectExpression(_props)); - return []; - } - - /** - * The logic for this is quite terse. It's because we need to - * support spread elements. We loop over all attributes, - * breaking on spreads, we then push a new object containing - * all prior attributes to an array for later processing. - */ - - function buildOpeningElementAttributes(attribs, file) { - let _props = []; - const objs = []; - - const { useSpread = false } = file.opts; - if (typeof useSpread !== "boolean") { - throw new Error( - "transform-react-jsx currently only accepts a boolean option for " + - "useSpread (defaults to false)", - ); - } - - const useBuiltIns = file.opts.useBuiltIns || false; - if (typeof useBuiltIns !== "boolean") { - throw new Error( - "transform-react-jsx currently only accepts a boolean option for " + - "useBuiltIns (defaults to false)", - ); - } - - if (useSpread && useBuiltIns) { - throw new Error( - "transform-react-jsx currently only accepts useBuiltIns or useSpread " + - "but not both", - ); - } - - if (useSpread) { - const props = attribs.map(convertAttribute); - return t.objectExpression(props); - } - - while (attribs.length) { - const prop = attribs.shift(); - if (t.isJSXSpreadAttribute(prop)) { - _props = pushProps(_props, objs); - objs.push(prop.argument); - } else { - _props.push(convertAttribute(prop)); - } - } - - pushProps(_props, objs); - - if (objs.length === 1) { - // only one object - attribs = objs[0]; - } else { - // looks like we have multiple objects - if (!t.isObjectExpression(objs[0])) { - objs.unshift(t.objectExpression([])); - } - - const helper = useBuiltIns - ? t.memberExpression(t.identifier("Object"), t.identifier("assign")) - : file.addHelper("extends"); - - // spread it - attribs = t.callExpression(helper, objs); - } - - return attribs; + function buildOpeningElementAttributes(attribs) { + const props = attribs.map(attrib => convertAttribute(attrib)); + return t.objectExpression(props); } function buildFragmentCall(path, file) { diff --git a/packages/babel-helper-transform-fixture-test-runner/package.json b/packages/babel-helper-transform-fixture-test-runner/package.json index 4f638d5028e4..16fcb1b35f74 100644 --- a/packages/babel-helper-transform-fixture-test-runner/package.json +++ b/packages/babel-helper-transform-fixture-test-runner/package.json @@ -20,10 +20,10 @@ "@babel/helper-fixtures": "workspace:^7.10.5", "@babel/polyfill": "workspace:^7.12.1", "babel-check-duplicated-nodes": "^1.0.0", - "jest-diff": "^24.8.0", + "escape-string-regexp": "^4.0.0", + "jest-diff": "^25.1.0", "lodash": "^4.17.19", "quick-lru": "5.1.0", - "resolve": "^1.3.2", "source-map": "^0.5.0" } } diff --git a/packages/babel-helper-transform-fixture-test-runner/src/index.js b/packages/babel-helper-transform-fixture-test-runner/src/index.js index 30dc091523e1..9a88d15baadf 100644 --- a/packages/babel-helper-transform-fixture-test-runner/src/index.js +++ b/packages/babel-helper-transform-fixture-test-runner/src/index.js @@ -4,10 +4,9 @@ import { buildExternalHelpers } from "@babel/core"; import getFixtures from "@babel/helper-fixtures"; import sourceMap from "source-map"; import { codeFrameColumns } from "@babel/code-frame"; -import escapeRegExp from "lodash/escapeRegExp"; +import escapeRegExp from "escape-string-regexp"; import * as helpers from "./helpers"; import merge from "lodash/merge"; -import resolve from "resolve"; import assert from "assert"; import fs from "fs"; import path from "path"; @@ -107,8 +106,8 @@ function runModuleInTestContext( context: Context, moduleCache: Object, ) { - const filename = resolve.sync(id, { - basedir: path.dirname(relativeFilename), + const filename = require.resolve(id, { + paths: [path.dirname(relativeFilename)], }); // Expose Node-internal modules if the tests want them. Note, this will not execute inside @@ -293,6 +292,7 @@ function run(task) { !expected.code && outputCode && !opts.throws && + !opts.rejects && fs.statSync(path.dirname(expected.loc)).isDirectory() && !process.env.CI ) { @@ -438,7 +438,7 @@ export default function ( function () { function runTask() { - run(task); + return run(task); } if ("sourceMap" in task.options === false) { @@ -452,13 +452,22 @@ export default function ( if (dynamicOpts) dynamicOpts(task.options, task); const throwMsg = task.options.throws; + const rejectMsg = task.options.rejects; if (throwMsg) { // internal api doesn't have this option but it's best not to pollute // the options object with useless options delete task.options.throws; - assert.throws(runTask, function (err) { - return throwMsg === true || err.message.indexOf(throwMsg) >= 0; + return assert.throws(runTask, function (err) { + assert.ok(err.message.includes(throwMsg)); + return true; + }); + } else if (rejectMsg) { + delete task.options.rejects; + + return assert.rejects(runTask, function (err) { + assert.ok(err.message.includes(rejectMsg)); + return true; }); } else { if (task.exec.code) { diff --git a/packages/babel-highlight/package.json b/packages/babel-highlight/package.json index 59192f3b4465..62096e3a4776 100644 --- a/packages/babel-highlight/package.json +++ b/packages/babel-highlight/package.json @@ -17,7 +17,7 @@ "dependencies": { "@babel/helper-validator-identifier": "workspace:^7.10.4", "chalk": "^2.0.0", - "js-tokens": "^4.0.0" + "js-tokens": "^6.0.0" }, "devDependencies": { "strip-ansi": "^4.0.0" diff --git a/packages/babel-highlight/src/index.js b/packages/babel-highlight/src/index.js index 64daa050b4bd..5ca0afdc9e2b 100644 --- a/packages/babel-highlight/src/index.js +++ b/packages/babel-highlight/src/index.js @@ -1,7 +1,21 @@ -import jsTokens, { matchToToken } from "js-tokens"; -import { isReservedWord, isKeyword } from "@babel/helper-validator-identifier"; +import jsTokens from "js-tokens"; +import { + isStrictReservedWord, + isKeyword, +} from "@babel/helper-validator-identifier"; import Chalk from "chalk"; +/** + * Names that are always allowed as identifiers, but also appear as keywords + * within certain syntactic productions. + * + * https://tc39.es/ecma262/#sec-keywords-and-reserved-words + * + * `target` has been omitted since it is very likely going to be a false + * positive. + */ +const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]); + /** * Chalk styles for token types. */ @@ -9,9 +23,8 @@ function getDefs(chalk) { return { keyword: chalk.cyan, capitalized: chalk.yellow, - jsx_tag: chalk.yellow, + jsxIdentifier: chalk.yellow, punctuator: chalk.yellow, - // bracket: intentionally omitted. number: chalk.magenta, string: chalk.green, regex: chalk.magenta, @@ -25,11 +38,6 @@ function getDefs(chalk) { */ const NEWLINE = /\r\n|[\n\r\u2028\u2029]/; -/** - * RegExp to test for what seems to be a JSX tag name. - */ -const JSX_TAG = /^[a-z][\w-]*$/i; - /** * RegExp to test for the three types of brackets. */ @@ -38,20 +46,14 @@ const BRACKET = /^[()[\]{}]$/; /** * Get the type of token, specifying punctuator type. */ -function getTokenType(match) { - const [offset, text] = match.slice(-2); - const token = matchToToken(match); - - if (token.type === "name") { - if (isKeyword(token.value) || isReservedWord(token.value)) { - return "keyword"; - } - +function getTokenType(token) { + if (token.type === "IdentifierName") { if ( - JSX_TAG.test(token.value) && - (text[offset - 1] === "<" || text.substr(offset - 2, 2) == " colorize(str)) .join("\n"); } else { - return args[0]; + highlighted += value; } - }); + } + + return highlighted; } type Options = { diff --git a/packages/babel-node/package.json b/packages/babel-node/package.json index f71fb06646cc..757a370f79d9 100644 --- a/packages/babel-node/package.json +++ b/packages/babel-node/package.json @@ -27,9 +27,7 @@ "commander": "^4.0.1", "core-js": "^3.2.1", "lodash": "^4.17.19", - "node-environment-flags": "^1.0.5", "regenerator-runtime": "^0.13.4", - "resolve": "^1.13.1", "v8flags": "^3.1.1" }, "peerDependencies": { @@ -40,7 +38,6 @@ "@babel/helper-fixtures": "workspace:*", "@babel/runtime": "workspace:*", "fs-readdir-recursive": "^1.0.0", - "make-dir": "^2.1.0", "rimraf": "^3.0.0" }, "bin": { diff --git a/packages/babel-node/src/_babel-node.js b/packages/babel-node/src/_babel-node.js index e2b61c9af04b..e69d27243cfb 100644 --- a/packages/babel-node/src/_babel-node.js +++ b/packages/babel-node/src/_babel-node.js @@ -8,7 +8,6 @@ import vm from "vm"; import "core-js/stable"; import "regenerator-runtime/runtime"; import register from "@babel/register"; -import resolve from "resolve"; import pkg from "../package.json"; @@ -189,8 +188,8 @@ if (program.eval || program.print) { // We have to handle require ourselves, as we want to require it in the context of babel-register if (program.require) { - require(resolve.sync(program.require, { - basedir: process.cwd(), + require(require.resolve(program.require, { + paths: [process.cwd()], })); } diff --git a/packages/babel-node/src/babel-node.js b/packages/babel-node/src/babel-node.js index 6d0866251b1d..b7b7ce0e5008 100755 --- a/packages/babel-node/src/babel-node.js +++ b/packages/babel-node/src/babel-node.js @@ -6,10 +6,6 @@ import getV8Flags from "v8flags"; import path from "path"; -// TODO: When support for node < 10.10 will be dropped, this package -// can be replaced with process.allowedNodeEnvironmentFlags -import allowedNodeEnvironmentFlags from "node-environment-flags"; - let args = [path.join(__dirname, "_babel-node")]; let babelArgs = process.argv.slice(2); @@ -59,7 +55,7 @@ getV8Flags(function (err, v8Flags) { flag === "debug" || // node debug foo.js flag === "inspect" || v8Flags.indexOf(getNormalizedV8Flag(flag)) >= 0 || - allowedNodeEnvironmentFlags.has(flag) + process.allowedNodeEnvironmentFlags.has(flag) ) { args.unshift(arg); } else { diff --git a/packages/babel-node/test/config.json b/packages/babel-node/test/config.json index 06c1c5853007..e82f5fcfa643 100644 --- a/packages/babel-node/test/config.json +++ b/packages/babel-node/test/config.json @@ -1,7 +1,7 @@ { "presets": [ "../../babel-preset-env", - ["../../babel-preset-react"] + ["../../babel-preset-react", { "runtime": "classic" }] ], "plugins": [ "../../babel-plugin-transform-strict-mode", diff --git a/packages/babel-node/test/index.js b/packages/babel-node/test/index.js index ca4571dfb0be..d865480e02c2 100644 --- a/packages/babel-node/test/index.js +++ b/packages/babel-node/test/index.js @@ -2,7 +2,6 @@ const includes = require("lodash/includes"); const readdir = require("fs-readdir-recursive"); const helper = require("@babel/helper-fixtures"); const rimraf = require("rimraf"); -const { sync: makeDirSync } = require("make-dir"); const child = require("child_process"); const merge = require("lodash/merge"); const path = require("path"); @@ -16,7 +15,7 @@ const fileFilter = function (x) { }; const outputFileSync = function (filePath, data) { - makeDirSync(path.dirname(filePath)); + fs.mkdirSync(path.dirname(filePath), { recursive: true }); fs.writeFileSync(filePath, data); }; diff --git a/packages/babel-parser/package.json b/packages/babel-parser/package.json index a5132223749b..06d4a1d77b49 100644 --- a/packages/babel-parser/package.json +++ b/packages/babel-parser/package.json @@ -29,7 +29,7 @@ "typings" ], "engines": { - "node": ">=6.0.0" + "node": ">=10.13.0" }, "devDependencies": { "@babel/code-frame": "workspace:*", diff --git a/packages/babel-parser/src/plugins/jsx/index.js b/packages/babel-parser/src/plugins/jsx/index.js index 923223b97601..722fe531f194 100644 --- a/packages/babel-parser/src/plugins/jsx/index.js +++ b/packages/babel-parser/src/plugins/jsx/index.js @@ -123,6 +123,20 @@ export default (superClass: Class): Class => chunkStart = this.state.pos; break; + case charCodes.greaterThan: + case charCodes.rightCurlyBrace: { + const htmlEntity = + ch === charCodes.rightCurlyBrace ? "}" : ">"; + throw this.raise( + this.state.pos, + `Unexpected token \`${ + this.input[this.state.pos] + }\`. Did you mean \`${htmlEntity}\` or \`{'${ + this.input[this.state.pos] + }'}\`?`, + ); + } + default: if (isNewLine(ch)) { out += this.input.slice(chunkStart, this.state.pos); @@ -344,9 +358,10 @@ export default (superClass: Class): Class => if (this.match(tt.braceR)) { node.expression = this.jsxParseEmptyExpression(); } else { - node.expression = this.parseExpression(); + node.expression = this.parseMaybeAssign(); } this.expect(tt.braceR); + return this.finishNode(node, "JSXExpressionContainer"); } diff --git a/packages/babel-parser/test/expressions/is-expression-babel-parser/fail/8/options.json b/packages/babel-parser/test/expressions/is-expression-babel-parser/fail/8/options.json index 4f434cf0aa86..df9bf9ac503d 100644 --- a/packages/babel-parser/test/expressions/is-expression-babel-parser/fail/8/options.json +++ b/packages/babel-parser/test/expressions/is-expression-babel-parser/fail/8/options.json @@ -1,3 +1,3 @@ { "strictMode": true -} \ No newline at end of file +} diff --git a/packages/babel-parser/test/fixtures/jsx/basic/13/input.js b/packages/babel-parser/test/fixtures/jsx/basic/13/input.js index f7525a0e00c1..2b1325cc94ff 100644 --- a/packages/babel-parser/test/fixtures/jsx/basic/13/input.js +++ b/packages/babel-parser/test/fixtures/jsx/basic/13/input.js @@ -1 +1 @@ - right=monkeys /> gorillas /> \ No newline at end of file + right=monkeys /{">"} gorillas /> diff --git a/packages/babel-parser/test/fixtures/jsx/basic/13/output.json b/packages/babel-parser/test/fixtures/jsx/basic/13/output.json index 0f199c3576f8..55abd830248e 100644 --- a/packages/babel-parser/test/fixtures/jsx/basic/13/output.json +++ b/packages/babel-parser/test/fixtures/jsx/basic/13/output.json @@ -1,21 +1,21 @@ { "type": "File", - "start":0,"end":57,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":57}}, + "start":0,"end":61,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":61}}, "program": { "type": "Program", - "start":0,"end":57,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":57}}, + "start":0,"end":61,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":61}}, "sourceType": "script", "interpreter": null, "body": [ { "type": "ExpressionStatement", - "start":0,"end":57,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":57}}, + "start":0,"end":61,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":61}}, "expression": { "type": "JSXElement", - "start":0,"end":57,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":57}}, + "start":0,"end":61,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":61}}, "openingElement": { "type": "JSXOpeningElement", - "start":0,"end":57,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":57}}, + "start":0,"end":61,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":61}}, "name": { "type": "JSXIdentifier", "start":1,"end":10,"loc":{"start":{"line":1,"column":1},"end":{"line":1,"column":10}}, @@ -50,7 +50,7 @@ }, { "type": "JSXAttribute", - "start":22,"end":54,"loc":{"start":{"line":1,"column":22},"end":{"line":1,"column":54}}, + "start":22,"end":58,"loc":{"start":{"line":1,"column":22},"end":{"line":1,"column":58}}, "name": { "type": "JSXIdentifier", "start":22,"end":27,"loc":{"start":{"line":1,"column":22},"end":{"line":1,"column":27}}, @@ -58,7 +58,7 @@ }, "value": { "type": "JSXElement", - "start":28,"end":54,"loc":{"start":{"line":1,"column":28},"end":{"line":1,"column":54}}, + "start":28,"end":58,"loc":{"start":{"line":1,"column":28},"end":{"line":1,"column":58}}, "openingElement": { "type": "JSXOpeningElement", "start":28,"end":31,"loc":{"start":{"line":1,"column":28},"end":{"line":1,"column":31}}, @@ -72,22 +72,44 @@ }, "closingElement": { "type": "JSXClosingElement", - "start":50,"end":54,"loc":{"start":{"line":1,"column":50},"end":{"line":1,"column":54}}, + "start":54,"end":58,"loc":{"start":{"line":1,"column":54},"end":{"line":1,"column":58}}, "name": { "type": "JSXIdentifier", - "start":52,"end":53,"loc":{"start":{"line":1,"column":52},"end":{"line":1,"column":53}}, + "start":56,"end":57,"loc":{"start":{"line":1,"column":56},"end":{"line":1,"column":57}}, "name": "b" } }, "children": [ { "type": "JSXText", - "start":31,"end":50,"loc":{"start":{"line":1,"column":31},"end":{"line":1,"column":50}}, + "start":31,"end":40,"loc":{"start":{"line":1,"column":31},"end":{"line":1,"column":40}}, "extra": { - "rawValue": "monkeys /> gorillas", - "raw": "monkeys /> gorillas" + "rawValue": "monkeys /", + "raw": "monkeys /" }, - "value": "monkeys /> gorillas" + "value": "monkeys /" + }, + { + "type": "JSXExpressionContainer", + "start":40,"end":45,"loc":{"start":{"line":1,"column":40},"end":{"line":1,"column":45}}, + "expression": { + "type": "StringLiteral", + "start":41,"end":44,"loc":{"start":{"line":1,"column":41},"end":{"line":1,"column":44}}, + "extra": { + "rawValue": ">", + "raw": "\">\"" + }, + "value": ">" + } + }, + { + "type": "JSXText", + "start":45,"end":54,"loc":{"start":{"line":1,"column":45},"end":{"line":1,"column":54}}, + "extra": { + "rawValue": " gorillas", + "raw": " gorillas" + }, + "value": " gorillas" } ] } diff --git a/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-angle-bracket/input.js b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-angle-bracket/input.js new file mode 100644 index 000000000000..980ff2c3a0da --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-angle-bracket/input.js @@ -0,0 +1 @@ +
{'>'}
diff --git a/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-angle-bracket/output.json b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-angle-bracket/output.json new file mode 100644 index 000000000000..3ed036c4460f --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-angle-bracket/output.json @@ -0,0 +1,166 @@ +{ + "type": "File", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "program": { + "type": "Program", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "sourceType": "script", + "interpreter": null, + "body": [ + { + "type": "ExpressionStatement", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "expression": { + "type": "JSXElement", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "openingElement": { + "type": "JSXOpeningElement", + "start": 0, + "end": 5, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 5 + } + }, + "name": { + "type": "JSXIdentifier", + "start": 1, + "end": 4, + "loc": { + "start": { + "line": 1, + "column": 1 + }, + "end": { + "line": 1, + "column": 4 + } + }, + "name": "div" + }, + "attributes": [], + "selfClosing": false + }, + "closingElement": { + "type": "JSXClosingElement", + "start": 10, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 10 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "name": { + "type": "JSXIdentifier", + "start": 12, + "end": 15, + "loc": { + "start": { + "line": 1, + "column": 12 + }, + "end": { + "line": 1, + "column": 15 + } + }, + "name": "div" + } + }, + "children": [ + { + "type": "JSXExpressionContainer", + "start": 5, + "end": 10, + "loc": { + "start": { + "line": 1, + "column": 5 + }, + "end": { + "line": 1, + "column": 10 + } + }, + "expression": { + "type": "StringLiteral", + "start": 6, + "end": 9, + "loc": { + "start": { + "line": 1, + "column": 6 + }, + "end": { + "line": 1, + "column": 9 + } + }, + "extra": { + "rawValue": ">", + "raw": "'>'" + }, + "value": ">" + } + } + ] + } + } + ], + "directives": [] + } +} \ No newline at end of file diff --git a/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-curly-brace/input.js b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-curly-brace/input.js new file mode 100644 index 000000000000..95b1a66963ab --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-curly-brace/input.js @@ -0,0 +1 @@ +
{'}'}
diff --git a/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-curly-brace/output.json b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-curly-brace/output.json new file mode 100644 index 000000000000..400d93163b32 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/basic/jsx-text-closing-curly-brace/output.json @@ -0,0 +1,166 @@ +{ + "type": "File", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "program": { + "type": "Program", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "sourceType": "script", + "interpreter": null, + "body": [ + { + "type": "ExpressionStatement", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "expression": { + "type": "JSXElement", + "start": 0, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "openingElement": { + "type": "JSXOpeningElement", + "start": 0, + "end": 5, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 5 + } + }, + "name": { + "type": "JSXIdentifier", + "start": 1, + "end": 4, + "loc": { + "start": { + "line": 1, + "column": 1 + }, + "end": { + "line": 1, + "column": 4 + } + }, + "name": "div" + }, + "attributes": [], + "selfClosing": false + }, + "closingElement": { + "type": "JSXClosingElement", + "start": 10, + "end": 16, + "loc": { + "start": { + "line": 1, + "column": 10 + }, + "end": { + "line": 1, + "column": 16 + } + }, + "name": { + "type": "JSXIdentifier", + "start": 12, + "end": 15, + "loc": { + "start": { + "line": 1, + "column": 12 + }, + "end": { + "line": 1, + "column": 15 + } + }, + "name": "div" + } + }, + "children": [ + { + "type": "JSXExpressionContainer", + "start": 5, + "end": 10, + "loc": { + "start": { + "line": 1, + "column": 5 + }, + "end": { + "line": 1, + "column": 10 + } + }, + "expression": { + "type": "StringLiteral", + "start": 6, + "end": 9, + "loc": { + "start": { + "line": 1, + "column": 6 + }, + "end": { + "line": 1, + "column": 9 + } + }, + "extra": { + "rawValue": "}", + "raw": "'}'" + }, + "value": "}" + } + } + ] + } + } + ], + "directives": [] + } +} \ No newline at end of file diff --git a/packages/babel-parser/test/fixtures/jsx/basic/sequence-expression/input.js b/packages/babel-parser/test/fixtures/jsx/basic/sequence-expression/input.js new file mode 100644 index 000000000000..e5828b633433 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/basic/sequence-expression/input.js @@ -0,0 +1 @@ +
{(console.log('foo'), JSON.stringify(props))}
\ No newline at end of file diff --git a/packages/babel-parser/test/fixtures/jsx/basic/sequence-expression/output.json b/packages/babel-parser/test/fixtures/jsx/basic/sequence-expression/output.json new file mode 100644 index 000000000000..64eca83036d0 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/basic/sequence-expression/output.json @@ -0,0 +1,338 @@ +{ + "type": "File", + "start": 0, + "end": 56, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 56 + } + }, + "program": { + "type": "Program", + "start": 0, + "end": 56, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 56 + } + }, + "sourceType": "script", + "interpreter": null, + "body": [ + { + "type": "ExpressionStatement", + "start": 0, + "end": 56, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 56 + } + }, + "expression": { + "type": "JSXElement", + "start": 0, + "end": 56, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 56 + } + }, + "openingElement": { + "type": "JSXOpeningElement", + "start": 0, + "end": 5, + "loc": { + "start": { + "line": 1, + "column": 0 + }, + "end": { + "line": 1, + "column": 5 + } + }, + "name": { + "type": "JSXIdentifier", + "start": 1, + "end": 4, + "loc": { + "start": { + "line": 1, + "column": 1 + }, + "end": { + "line": 1, + "column": 4 + } + }, + "name": "div" + }, + "attributes": [], + "selfClosing": false + }, + "closingElement": { + "type": "JSXClosingElement", + "start": 50, + "end": 56, + "loc": { + "start": { + "line": 1, + "column": 50 + }, + "end": { + "line": 1, + "column": 56 + } + }, + "name": { + "type": "JSXIdentifier", + "start": 52, + "end": 55, + "loc": { + "start": { + "line": 1, + "column": 52 + }, + "end": { + "line": 1, + "column": 55 + } + }, + "name": "div" + } + }, + "children": [ + { + "type": "JSXExpressionContainer", + "start": 5, + "end": 50, + "loc": { + "start": { + "line": 1, + "column": 5 + }, + "end": { + "line": 1, + "column": 50 + } + }, + "expression": { + "type": "SequenceExpression", + "start": 7, + "end": 48, + "loc": { + "start": { + "line": 1, + "column": 7 + }, + "end": { + "line": 1, + "column": 48 + } + }, + "expressions": [ + { + "type": "CallExpression", + "start": 7, + "end": 25, + "loc": { + "start": { + "line": 1, + "column": 7 + }, + "end": { + "line": 1, + "column": 25 + } + }, + "callee": { + "type": "MemberExpression", + "start": 7, + "end": 18, + "loc": { + "start": { + "line": 1, + "column": 7 + }, + "end": { + "line": 1, + "column": 18 + } + }, + "object": { + "type": "Identifier", + "start": 7, + "end": 14, + "loc": { + "start": { + "line": 1, + "column": 7 + }, + "end": { + "line": 1, + "column": 14 + }, + "identifierName": "console" + }, + "name": "console" + }, + "property": { + "type": "Identifier", + "start": 15, + "end": 18, + "loc": { + "start": { + "line": 1, + "column": 15 + }, + "end": { + "line": 1, + "column": 18 + }, + "identifierName": "log" + }, + "name": "log" + }, + "computed": false + }, + "arguments": [ + { + "type": "StringLiteral", + "start": 19, + "end": 24, + "loc": { + "start": { + "line": 1, + "column": 19 + }, + "end": { + "line": 1, + "column": 24 + } + }, + "extra": { + "rawValue": "foo", + "raw": "'foo'" + }, + "value": "foo" + } + ] + }, + { + "type": "CallExpression", + "start": 27, + "end": 48, + "loc": { + "start": { + "line": 1, + "column": 27 + }, + "end": { + "line": 1, + "column": 48 + } + }, + "callee": { + "type": "MemberExpression", + "start": 27, + "end": 41, + "loc": { + "start": { + "line": 1, + "column": 27 + }, + "end": { + "line": 1, + "column": 41 + } + }, + "object": { + "type": "Identifier", + "start": 27, + "end": 31, + "loc": { + "start": { + "line": 1, + "column": 27 + }, + "end": { + "line": 1, + "column": 31 + }, + "identifierName": "JSON" + }, + "name": "JSON" + }, + "property": { + "type": "Identifier", + "start": 32, + "end": 41, + "loc": { + "start": { + "line": 1, + "column": 32 + }, + "end": { + "line": 1, + "column": 41 + }, + "identifierName": "stringify" + }, + "name": "stringify" + }, + "computed": false + }, + "arguments": [ + { + "type": "Identifier", + "start": 42, + "end": 47, + "loc": { + "start": { + "line": 1, + "column": 42 + }, + "end": { + "line": 1, + "column": 47 + }, + "identifierName": "props" + }, + "name": "props" + } + ] + } + ], + "extra": { + "parenthesized": true, + "parenStart": 6 + } + } + } + ] + } + } + ], + "directives": [] + } +} diff --git a/packages/babel-parser/test/fixtures/jsx/errors/attribute-sequence-expression/input.js b/packages/babel-parser/test/fixtures/jsx/errors/attribute-sequence-expression/input.js new file mode 100644 index 000000000000..90b46deab922 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/attribute-sequence-expression/input.js @@ -0,0 +1 @@ +
\ No newline at end of file diff --git a/packages/babel-parser/test/fixtures/jsx/errors/attribute-sequence-expression/options.json b/packages/babel-parser/test/fixtures/jsx/errors/attribute-sequence-expression/options.json new file mode 100644 index 000000000000..d83e23b4d116 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/attribute-sequence-expression/options.json @@ -0,0 +1,3 @@ +{ + "throws": "Unexpected token, expected \"}\" (1:28)" +} diff --git a/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-angle-bracket/input.js b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-angle-bracket/input.js new file mode 100644 index 000000000000..4397f584cbb1 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-angle-bracket/input.js @@ -0,0 +1 @@ +
>
diff --git a/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-angle-bracket/options.json b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-angle-bracket/options.json new file mode 100644 index 000000000000..38653170dfec --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-angle-bracket/options.json @@ -0,0 +1,4 @@ +{ + "plugins": ["jsx", "flow"], + "throws": "Unexpected token `>`. Did you mean `>` or `{'>'}`? (1:5)" +} diff --git a/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-curly-brace/input.js b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-curly-brace/input.js new file mode 100644 index 000000000000..1f7fd22cc8bc --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-curly-brace/input.js @@ -0,0 +1 @@ +
}
diff --git a/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-curly-brace/options.json b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-curly-brace/options.json new file mode 100644 index 000000000000..bcd8eb30b569 --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/jsx-text-closing-curly-brace/options.json @@ -0,0 +1,4 @@ +{ + "plugins": ["jsx", "flow"], + "throws": "Unexpected token `}`. Did you mean `}` or `{'}'}`? (1:5)" +} diff --git a/packages/babel-parser/test/fixtures/jsx/errors/sequence-expression/input.js b/packages/babel-parser/test/fixtures/jsx/errors/sequence-expression/input.js new file mode 100644 index 000000000000..17d05e6bdcda --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/sequence-expression/input.js @@ -0,0 +1 @@ +
{console.log('foo'), JSON.stringify(props)}
\ No newline at end of file diff --git a/packages/babel-parser/test/fixtures/jsx/errors/sequence-expression/options.json b/packages/babel-parser/test/fixtures/jsx/errors/sequence-expression/options.json new file mode 100644 index 000000000000..d4d8605f0d6d --- /dev/null +++ b/packages/babel-parser/test/fixtures/jsx/errors/sequence-expression/options.json @@ -0,0 +1,3 @@ +{ + "throws": "Unexpected token, expected \"}\" (1:24)" +} diff --git a/packages/babel-parser/test/fixtures/jsx/errors/unclosed-jsx-element/options.json b/packages/babel-parser/test/fixtures/jsx/errors/unclosed-jsx-element/options.json index 05048c2000ee..414dc917b93b 100644 --- a/packages/babel-parser/test/fixtures/jsx/errors/unclosed-jsx-element/options.json +++ b/packages/babel-parser/test/fixtures/jsx/errors/unclosed-jsx-element/options.json @@ -1,4 +1,7 @@ { - "plugins": ["jsx"], - "throws": "Unexpected token (1:13)" -} + "plugins": [ + "jsx", + "estree" + ], + "throws": "Unexpected token `>`. Did you mean `>` or `{'>'}`? (1:9)" +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/issue-9905/options.json b/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/issue-9905/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/issue-9905/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method-with-finally-multiple-parallel/options.json b/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method-with-finally-multiple-parallel/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method-with-finally-multiple-parallel/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method-with-finally-multiple-serial/options.json b/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method-with-finally-multiple-serial/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method-with-finally-multiple-serial/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method/options.json b/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/return-method/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types-loose/output.js b/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types-loose/output.js index 18cbcb0e7e00..688eb31db97f 100644 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types-loose/output.js +++ b/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types-loose/output.js @@ -1,6 +1,7 @@ class C { // Output should not use `_initialiseProps` constructor(T) { + this.x = void 0; this.y = 0; } diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types/output.js b/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types/output.js index c85b2477ed4d..e6d715c07a9a 100644 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types/output.js +++ b/packages/babel-plugin-proposal-class-properties/test/fixtures/compile-to-class/constructor-collision-ignores-types/output.js @@ -3,6 +3,8 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope class C { // Output should not use `_initialiseProps` constructor(T) { + _defineProperty(this, "x", void 0); + _defineProperty(this, "y", 0); } diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/private-loose/canonical/options.json b/packages/babel-plugin-proposal-class-properties/test/fixtures/private-loose/canonical/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/private-loose/canonical/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/private/canonical/options.json b/packages/babel-plugin-proposal-class-properties/test/fixtures/private/canonical/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/private/canonical/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/public/native-classes/options.json b/packages/babel-plugin-proposal-class-properties/test/fixtures/public/native-classes/options.json index 89a37faa03b7..61bbcd402c04 100644 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/public/native-classes/options.json +++ b/packages/babel-plugin-proposal-class-properties/test/fixtures/public/native-classes/options.json @@ -1,9 +1,8 @@ { - "minNodeVersion": "6.0.0", "plugins": [ "external-helpers", "proposal-class-properties", "transform-block-scoping", "syntax-class-properties" ] -} +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-do-expressions/test/fixtures/do-expressions/await/options.json b/packages/babel-plugin-proposal-do-expressions/test/fixtures/do-expressions/await/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-proposal-do-expressions/test/fixtures/do-expressions/await/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-proposal-function-sent/test/fixtures/function-sent/basic/options.json b/packages/babel-plugin-proposal-function-sent/test/fixtures/function-sent/basic/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-function-sent/test/fixtures/function-sent/basic/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-function-sent/test/fixtures/function-sent/multiple/options.json b/packages/babel-plugin-proposal-function-sent/test/fixtures/function-sent/multiple/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-function-sent/test/fixtures/function-sent/multiple/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json b/packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json b/packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/fsharp/await/options.json b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/fsharp/await/options.json index 970314ed16fe..5a545035d4ed 100644 --- a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/fsharp/await/options.json +++ b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/fsharp/await/options.json @@ -1,7 +1,13 @@ { - "plugins": [["proposal-pipeline-operator", { "proposal": "fsharp" }]], + "plugins": [ + [ + "proposal-pipeline-operator", + { + "proposal": "fsharp" + } + ] + ], "parserOpts": { "allowReturnOutsideFunction": true - }, - "minNodeVersion": "8.0.0" -} + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/minimal/async-arrow/options.json b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/minimal/async-arrow/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/minimal/async-arrow/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/minimal/destructure-arrow-param/options.json b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/minimal/destructure-arrow-param/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/minimal/destructure-arrow-param/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart+arrow/await/options.json b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart+arrow/await/options.json index f19c36b8eef1..e2c041e7db10 100644 --- a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart+arrow/await/options.json +++ b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart+arrow/await/options.json @@ -1,6 +1,5 @@ { "parserOpts": { "allowReturnOutsideFunction": true - }, - "minNodeVersion": "8.0.0" -} + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart/await/options.json b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart/await/options.json index df1848815387..4bf8a5a8049f 100644 --- a/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart/await/options.json +++ b/packages/babel-plugin-proposal-pipeline-operator/test/fixtures/smart/await/options.json @@ -1,7 +1,13 @@ { - "plugins": [["proposal-pipeline-operator", { "proposal": "smart" }]], + "plugins": [ + [ + "proposal-pipeline-operator", + { + "proposal": "smart" + } + ] + ], "parserOpts": { "allowReturnOutsideFunction": true - }, - "minNodeVersion": "8.0.0" -} + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-loose/async/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-loose/async/options.json index 580349bcb7ba..b736cc130d2d 100644 --- a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-loose/async/options.json +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-loose/async/options.json @@ -1,11 +1,25 @@ { - "minNodeVersion": "8.0.0", "plugins": [ - ["external-helpers", { "helperVersion": "7.1000.0" }], - ["proposal-private-methods", { "loose": true }], - ["proposal-class-properties", { "loose": true }] + [ + "external-helpers", + { + "helperVersion": "7.1000.0" + } + ], + [ + "proposal-private-methods", + { + "loose": true + } + ], + [ + "proposal-class-properties", + { + "loose": true + } + ] ], "parserOpts": { "allowReturnOutsideFunction": true } -} +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method/async/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method/async/options.json index d102004d8783..95be0f0cbd46 100644 --- a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method/async/options.json +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method/async/options.json @@ -1,11 +1,15 @@ { - "minNodeVersion": "8.0.0", "plugins": [ - ["external-helpers", { "helperVersion": "7.1000.0" }], + [ + "external-helpers", + { + "helperVersion": "7.1000.0" + } + ], "proposal-private-methods", "proposal-class-properties" ], "parserOpts": { "allowReturnOutsideFunction": true } -} +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-loose/async/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-loose/async/options.json index a34201ad4f9b..2ee88ce2a66c 100644 --- a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-loose/async/options.json +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-loose/async/options.json @@ -1,5 +1,4 @@ { - "minNodeVersion": "8.0.0", "plugins": [ [ "external-helpers", @@ -15,4 +14,4 @@ "parserOpts": { "allowReturnOutsideFunction": true } -} +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method/async/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method/async/options.json index a34201ad4f9b..2ee88ce2a66c 100644 --- a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method/async/options.json +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method/async/options.json @@ -1,5 +1,4 @@ { - "minNodeVersion": "8.0.0", "plugins": [ [ "external-helpers", @@ -15,4 +14,4 @@ "parserOpts": { "allowReturnOutsideFunction": true } -} +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-unicode-property-regex/package.json b/packages/babel-plugin-proposal-unicode-property-regex/package.json index 34b7f5182ddb..d8e4e019f3a9 100644 --- a/packages/babel-plugin-proposal-unicode-property-regex/package.json +++ b/packages/babel-plugin-proposal-unicode-property-regex/package.json @@ -8,9 +8,6 @@ "access": "public" }, "main": "lib/index.js", - "engines": { - "node": ">=4" - }, "keywords": [ "babel-plugin", "regex", diff --git a/packages/babel-plugin-syntax-flow/src/index.js b/packages/babel-plugin-syntax-flow/src/index.js index 72fb7dc60b95..5bfadc760aa0 100644 --- a/packages/babel-plugin-syntax-flow/src/index.js +++ b/packages/babel-plugin-syntax-flow/src/index.js @@ -19,16 +19,6 @@ export default declare((api, options) => { name: "syntax-flow", manipulateOptions(opts, parserOpts) { - // If the file has already enabled TS, assume that this is not a - // valid Flowtype file. - if ( - parserOpts.plugins.some( - p => (Array.isArray(p) ? p[0] : p) === "typescript", - ) - ) { - return; - } - parserOpts.plugins.push(["flow", { all, enums }]); }, }; diff --git a/packages/babel-plugin-syntax-jsx/src/index.js b/packages/babel-plugin-syntax-jsx/src/index.js index e9d2ae493828..b5ca6834e651 100644 --- a/packages/babel-plugin-syntax-jsx/src/index.js +++ b/packages/babel-plugin-syntax-jsx/src/index.js @@ -7,16 +7,6 @@ export default declare(api => { name: "syntax-jsx", manipulateOptions(opts, parserOpts) { - // If the Typescript plugin already ran, it will have decided whether - // or not this is a TSX file. - if ( - parserOpts.plugins.some( - p => (Array.isArray(p) ? p[0] : p) === "typescript", - ) - ) { - return; - } - parserOpts.plugins.push("jsx"); }, }; diff --git a/packages/babel-plugin-syntax-typescript/src/index.js b/packages/babel-plugin-syntax-typescript/src/index.js index c4c5eddaa27b..39df9a53cf85 100644 --- a/packages/babel-plugin-syntax-typescript/src/index.js +++ b/packages/babel-plugin-syntax-typescript/src/index.js @@ -1,46 +1,13 @@ import { declare } from "@babel/helper-plugin-utils"; -function removePlugin(plugins, name) { - const indices = []; - plugins.forEach((plugin, i) => { - const n = Array.isArray(plugin) ? plugin[0] : plugin; - - if (n === name) { - indices.unshift(i); - } - }); - - for (const i of indices) { - plugins.splice(i, 1); - } -} - -export default declare((api, { isTSX }) => { +export default declare(api => { api.assertVersion(7); return { name: "syntax-typescript", manipulateOptions(opts, parserOpts) { - const { plugins } = parserOpts; - // If the Flow syntax plugin already ran, remove it since Typescript - // takes priority. - removePlugin(plugins, "flow"); - - // If the JSX syntax plugin already ran, remove it because JSX handling - // in TS depends on the extensions, and is purely dependent on 'isTSX'. - removePlugin(plugins, "jsx"); - - parserOpts.plugins.push( - "typescript", - "classProperties", - // TODO: This is enabled by default now, remove in Babel 8 - "objectRestSpread", - ); - - if (isTSX) { - parserOpts.plugins.push("jsx"); - } + parserOpts.plugins.push("typescript", "classProperties"); }, }; }); diff --git a/packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/7178/options.json b/packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/7178/options.json index e1385e03944b..6dc5e9a6a355 100644 --- a/packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/7178/options.json +++ b/packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/7178/options.json @@ -2,7 +2,7 @@ "plugins": [ "external-helpers", "transform-async-to-generator", - "transform-react-jsx", + ["transform-react-jsx", { "runtime": "classic" }], "transform-react-constant-elements" ] } diff --git a/packages/babel-plugin-transform-block-scoping/test/fixtures/general/options.json b/packages/babel-plugin-transform-block-scoping/test/fixtures/general/options.json index d480b6d0abae..41e2cadf635e 100644 --- a/packages/babel-plugin-transform-block-scoping/test/fixtures/general/options.json +++ b/packages/babel-plugin-transform-block-scoping/test/fixtures/general/options.json @@ -2,7 +2,7 @@ "plugins": [ "transform-block-scoping", "syntax-jsx", - "transform-react-jsx", + ["transform-react-jsx", { "runtime": "classic" }], "transform-block-scoped-functions", "transform-arrow-functions" ] diff --git a/packages/babel-plugin-transform-classes/package.json b/packages/babel-plugin-transform-classes/package.json index 326924e4925b..e8926e1ab6c2 100644 --- a/packages/babel-plugin-transform-classes/package.json +++ b/packages/babel-plugin-transform-classes/package.json @@ -20,7 +20,7 @@ "@babel/helper-plugin-utils": "workspace:^7.10.4", "@babel/helper-replace-supers": "workspace:^7.12.1", "@babel/helper-split-export-declaration": "workspace:^7.10.4", - "globals": "^11.1.0" + "globals": "^12.3.0" }, "keywords": [ "babel-plugin" diff --git a/packages/babel-plugin-transform-classes/test/fixtures/regression/options.json b/packages/babel-plugin-transform-classes/test/fixtures/regression/options.json index c58ca4ae2fa3..5afc96f77408 100644 --- a/packages/babel-plugin-transform-classes/test/fixtures/regression/options.json +++ b/packages/babel-plugin-transform-classes/test/fixtures/regression/options.json @@ -1,4 +1,7 @@ { "plugins": ["external-helpers", "proposal-class-properties"], - "presets": ["env", "react"] + "presets": [ + "env", + ["react", { "runtime": "classic" }] + ] } diff --git a/packages/babel-plugin-transform-flow-strip-types/src/index.js b/packages/babel-plugin-transform-flow-strip-types/src/index.js index 7779fd75232b..ba90c5b70b94 100644 --- a/packages/babel-plugin-transform-flow-strip-types/src/index.js +++ b/packages/babel-plugin-transform-flow-strip-types/src/index.js @@ -101,8 +101,6 @@ export default declare((api, opts) => { if (node.declare) { child.remove(); - } else if (!allowDeclareFields && !node.value && !node.decorators) { - child.remove(); } else { node.variance = null; node.typeAnnotation = null; diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/input.js b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/input.js similarity index 72% rename from packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/input.js rename to packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/input.js index 005df4e1244e..d3463e07221c 100644 --- a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/input.js +++ b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/input.js @@ -1,5 +1,4 @@ class X { foo = 2 bar: number = 3 - baz: ?string } diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/options.json b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/options.json similarity index 100% rename from packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/options.json rename to packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/options.json diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/output.js b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/output.js similarity index 100% rename from packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-values/output.js rename to packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-initialized/output.js diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/input.js b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/input.js similarity index 100% rename from packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/input.js rename to packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/input.js diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/options.json b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/options.json similarity index 70% rename from packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/options.json rename to packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/options.json index e85428a1dc6f..a86bb2ea3602 100644 --- a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/options.json +++ b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/options.json @@ -1,7 +1,7 @@ { "plugins": [ "transform-flow-strip-types", - "transform-classes", + "proposal-class-properties", "external-helpers" ] } diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/output.js b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/output.js new file mode 100644 index 000000000000..a6ad6f90da87 --- /dev/null +++ b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-fields-uninitialized/output.js @@ -0,0 +1,6 @@ +class Test { + constructor() { + babelHelpers.defineProperty(this, "prop", void 0); + } + +} diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/output.js b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/output.js deleted file mode 100644 index 864e3000b909..000000000000 --- a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/regression/class-prop-types/output.js +++ /dev/null @@ -1,5 +0,0 @@ -let Test = function Test() { - "use strict"; - - babelHelpers.classCallCheck(this, Test); -}; diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/def-site-variance/output.js b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/def-site-variance/output.js index 2030dde8940e..4049b830e234 100644 --- a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/def-site-variance/output.js +++ b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/def-site-variance/output.js @@ -2,6 +2,10 @@ class C1 {} function f() {} -class C2 {} +class C2 { + p; +} -class C3 {} +class C3 { + p; +} diff --git a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/strip-type-annotations/output.mjs b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/strip-type-annotations/output.mjs index 8df6545f3906..4d6a0e08310d 100644 --- a/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/strip-type-annotations/output.mjs +++ b/packages/babel-plugin-transform-flow-strip-types/test/fixtures/strip-types/strip-type-annotations/output.mjs @@ -119,9 +119,15 @@ class Foo8 { function foo19(requiredParam, optParam) {} -class Foo9 {} +class Foo9 { + prop1; + prop2; +} -class Foo10 {} +class Foo10 { + static prop1; + prop2; +} class Foo11 { #prop1; diff --git a/packages/babel-plugin-transform-function-name/test/fixtures/function-name/export-default-arrow-renaming-3/options.json b/packages/babel-plugin-transform-function-name/test/fixtures/function-name/export-default-arrow-renaming-3/options.json index 4ffef06dbfb5..5a01758bcc3f 100644 --- a/packages/babel-plugin-transform-function-name/test/fixtures/function-name/export-default-arrow-renaming-3/options.json +++ b/packages/babel-plugin-transform-function-name/test/fixtures/function-name/export-default-arrow-renaming-3/options.json @@ -1,3 +1,6 @@ { - "presets": ["env", "react"] + "presets": [ + "env", + ["react", { "runtime": "classic" }] + ] } diff --git a/packages/babel-plugin-transform-named-capturing-groups-regex/test/fixtures/runtime/issue-10393/options.json b/packages/babel-plugin-transform-named-capturing-groups-regex/test/fixtures/runtime/issue-10393/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-transform-named-capturing-groups-regex/test/fixtures/runtime/issue-10393/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-transform-named-capturing-groups-regex/test/fixtures/runtime/issue-10601/options.json b/packages/babel-plugin-transform-named-capturing-groups-regex/test/fixtures/runtime/issue-10601/options.json deleted file mode 100644 index 2454c2169cf8..000000000000 --- a/packages/babel-plugin-transform-named-capturing-groups-regex/test/fixtures/runtime/issue-10601/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "8.0.0" -} diff --git a/packages/babel-plugin-transform-new-target/test/fixtures/exec/reflect-class/options.json b/packages/babel-plugin-transform-new-target/test/fixtures/exec/reflect-class/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-transform-new-target/test/fixtures/exec/reflect-class/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-transform-new-target/test/fixtures/exec/reflect-function/options.json b/packages/babel-plugin-transform-new-target/test/fixtures/exec/reflect-function/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-transform-new-target/test/fixtures/exec/reflect-function/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-transform-new-target/test/fixtures/options.json b/packages/babel-plugin-transform-new-target/test/fixtures/options.json index 1cf7776014ef..8cde7b598a87 100644 --- a/packages/babel-plugin-transform-new-target/test/fixtures/options.json +++ b/packages/babel-plugin-transform-new-target/test/fixtures/options.json @@ -1,4 +1,3 @@ { - "plugins": ["transform-new-target"], - "minNodeVersion": "4.0.0" + "plugins": ["transform-new-target"] } diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json index dc660e0bf4bc..f1ab7207da72 100644 --- a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json +++ b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json @@ -1,4 +1,3 @@ { - "minNodeVersion": "6.0.0", "plugins": ["transform-object-super"] } diff --git a/packages/babel-plugin-transform-parameters/test/fixtures/parameters/options.json b/packages/babel-plugin-transform-parameters/test/fixtures/parameters/options.json index 81ab23a54067..90bb044ba39d 100644 --- a/packages/babel-plugin-transform-parameters/test/fixtures/parameters/options.json +++ b/packages/babel-plugin-transform-parameters/test/fixtures/parameters/options.json @@ -2,8 +2,6 @@ "plugins": [ "proposal-class-properties", ["external-helpers", { "helperVersion": "7.100.0" }], - "syntax-typescript", - "syntax-flow", "transform-parameters", "transform-block-scoping", "transform-spread", diff --git a/packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/input.js b/packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/input.ts similarity index 100% rename from packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/input.js rename to packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/input.ts diff --git a/packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/options.json b/packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/options.json new file mode 100644 index 000000000000..abf00ef61215 --- /dev/null +++ b/packages/babel-plugin-transform-parameters/test/fixtures/parameters/rest-ts-this-parameter/options.json @@ -0,0 +1,6 @@ +{ + "plugins": [ + "transform-parameters", + "syntax-typescript" + ] +} diff --git a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export-default/options.json b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export-default/options.json index 72ce72ca0b17..646be547c24b 100644 --- a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export-default/options.json +++ b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export-default/options.json @@ -1,3 +1,6 @@ { - "plugins": ["transform-react-jsx", "transform-react-constant-elements"] + "plugins": [ + ["transform-react-jsx", { "runtime": "classic" }], + "transform-react-constant-elements" + ] } diff --git a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export/options.json b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export/options.json index 72ce72ca0b17..646be547c24b 100644 --- a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export/options.json +++ b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/regression-node-type-export/options.json @@ -1,3 +1,6 @@ { - "plugins": ["transform-react-jsx", "transform-react-constant-elements"] + "plugins": [ + ["transform-react-jsx", { "runtime": "classic" }], + "transform-react-constant-elements" + ] } diff --git a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/lowercase-member-expression/options.json b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/lowercase-member-expression/options.json index 0979da7affb5..cf2845dc2ab6 100644 --- a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/lowercase-member-expression/options.json +++ b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/lowercase-member-expression/options.json @@ -3,7 +3,7 @@ "external-helpers", "syntax-jsx", "transform-react-inline-elements", - "transform-react-jsx", + ["transform-react-jsx", { "runtime": "classic" }], "transform-modules-commonjs" ] } diff --git a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/member-expression/options.json b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/member-expression/options.json index 0979da7affb5..cf2845dc2ab6 100644 --- a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/member-expression/options.json +++ b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/member-expression/options.json @@ -3,7 +3,7 @@ "external-helpers", "syntax-jsx", "transform-react-inline-elements", - "transform-react-jsx", + ["transform-react-jsx", { "runtime": "classic" }], "transform-modules-commonjs" ] } diff --git a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/spread-deopt/output.js b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/spread-deopt/output.js index 5f16ff6ba3ea..9271d044f37a 100644 --- a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/spread-deopt/output.js +++ b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/inline-elements/spread-deopt/output.js @@ -1,2 +1,3 @@ /*#__PURE__*/ -React.createElement(Foo, bar); +React.createElement(Foo, { ...bar +}); diff --git a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/options.json b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/options.json index ba074de5fb6d..59c68d65b140 100644 --- a/packages/babel-plugin-transform-react-inline-elements/test/fixtures/options.json +++ b/packages/babel-plugin-transform-react-inline-elements/test/fixtures/options.json @@ -3,6 +3,6 @@ "external-helpers", "syntax-jsx", "transform-react-inline-elements", - "transform-react-jsx" + ["transform-react-jsx", { "runtime": "classic" }] ] } diff --git a/packages/babel-plugin-transform-react-jsx/src/index.js b/packages/babel-plugin-transform-react-jsx/src/index.js index 4e0c5b69b3bb..69e277cf61af 100644 --- a/packages/babel-plugin-transform-react-jsx/src/index.js +++ b/packages/babel-plugin-transform-react-jsx/src/index.js @@ -5,14 +5,14 @@ import transformAutomatic from "./transform-automatic"; import { declare } from "@babel/helper-plugin-utils"; export default declare((api, options) => { - const { runtime = "classic" } = options; + const { runtime = "automatic" } = options; // we throw a warning in helper-builder-react-jsx-experimental if runtime // is neither automatic or classic because we will remove this file // in v8.0.0 if (runtime === "classic") { return transformClassic(api, options); - } else { - return transformAutomatic(api, options); } + + return transformAutomatic(api, options); }); diff --git a/packages/babel-plugin-transform-react-jsx/src/transform-classic.js b/packages/babel-plugin-transform-react-jsx/src/transform-classic.js index d74b16078fe0..abae11798626 100644 --- a/packages/babel-plugin-transform-react-jsx/src/transform-classic.js +++ b/packages/babel-plugin-transform-react-jsx/src/transform-classic.js @@ -19,6 +19,27 @@ export default declare((api, options) => { const JSX_ANNOTATION_REGEX = /\*?\s*@jsx\s+([^\s]+)/; const JSX_FRAG_ANNOTATION_REGEX = /\*?\s*@jsxFrag\s+([^\s]+)/; + if ("useSpread" in options) { + throw new Error( + 'transform-react-jsx: Since Babel 8, an inline object with spread elements is always used, and the "useSpread" option is no longer available. Please remove it from your config.', + ); + } + + if ("useBuiltIns" in options) { + const useBuiltInsFormatted = JSON.stringify(options.useBuiltIns); + throw new Error( + `transform-react-jsx: Since "useBuiltIns" is removed in Babel 8, you must remove it from your config. +- Babel 8 now transforms JSX spread to object spread. If you need to transpile object spread with +\`useBuiltIns: ${useBuiltInsFormatted}\`, you can use the following config +{ + "plugins": [ + "@babel/plugin-transform-react-jsx", + ["@babel/plugin-proposal-object-rest-spread", { "loose": true, "useBuiltIns": ${useBuiltInsFormatted} }] + ] +}`, + ); + } + // returns a closure that returns an identifier or memberExpression node // based on the given id const createIdentifierParser = (id: string) => () => { diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxattribute/output.mjs b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxattribute/output.mjs index 9a5aedeff449..df676463936c 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxattribute/output.mjs +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxattribute/output.mjs @@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime"; /*#__PURE__*/ _jsx("div", { - id: "w\xF4w" + id: "wôw" }); /*#__PURE__*/ diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxtext/output.mjs b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxtext/output.mjs index 32cb47cd42ed..74025e452257 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxtext/output.mjs +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReact/should-escape-xhtml-jsxtext/output.mjs @@ -8,7 +8,7 @@ _jsx("div", { /*#__PURE__*/ _jsx("div", { - children: "w\xF4w" + children: "wôw" }); /*#__PURE__*/ diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxattribute/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxattribute/output.js index b0727d295e1b..e609bfe79f11 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxattribute/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxattribute/output.js @@ -2,7 +2,7 @@ /*#__PURE__*/ React.createElement("div", { - id: "w\xF4w" + id: "wôw" }); /*#__PURE__*/ diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxtext/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxtext/output.js index c4288df1dd0f..208e24cee0bf 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxtext/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/nextReactClassic/should-escape-xhtml-jsxtext/output.js @@ -4,7 +4,7 @@ React.createElement("div", null, "wow"); /*#__PURE__*/ -React.createElement("div", null, "w\xF4w"); +React.createElement("div", null, "wôw"); /*#__PURE__*/ React.createElement("div", null, "w & w"); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/input.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/input.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/options.json new file mode 100644 index 000000000000..3f0390431481 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pure": false, "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/output.js new file mode 100644 index 000000000000..3cd05d5f9f2f --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma-classic-runtime/output.js @@ -0,0 +1 @@ +React.createElement("div", null); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma/output.js index 3cd05d5f9f2f..fd783106b63c 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-default-pragma/output.js @@ -1 +1,3 @@ -React.createElement("div", null); +var _reactJsxRuntime = require("react/jsx-runtime"); + +_reactJsxRuntime.jsx("div", {}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/input.js new file mode 100644 index 000000000000..6b8761b4a90a --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/input.js @@ -0,0 +1,3 @@ +/* @jsx h */ + +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/options.json new file mode 100644 index 000000000000..3f0390431481 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pure": false, "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment/options.json index 8608ef373955..50880d98fa4e 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-comment/options.json @@ -1,5 +1,6 @@ { "plugins": [ ["transform-react-jsx", { "pure": false }] - ] + ], + "throws": "pragma and pragmaFrag cannot be set when runtime is automatic." } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/input.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/input.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/options.json new file mode 100644 index 000000000000..9a94a0e2ae35 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pragma": "h", "pure": false, "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option/options.json index 65d9e8ae0d93..e99ec28707d6 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/false-pragma-option/options.json @@ -1,5 +1,6 @@ { "plugins": [ ["transform-react-jsx", { "pragma": "h", "pure": false }] - ] + ], + "throws": "pragma and pragmaFrag cannot be set when runtime is automatic." } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/input.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/input.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/options.json new file mode 100644 index 000000000000..1eb39754fc94 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pure": true, "runtime": "classic" }] + ] +} diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/js-valid/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/output.js similarity index 100% rename from packages/babel-preset-typescript/test/fixtures/jsx-compat/js-valid/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma/output.js index 6ad0513bb203..5518c29044fd 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-default-pragma/output.js @@ -1,2 +1,4 @@ +var _reactJsxRuntime = require("react/jsx-runtime"); + /*#__PURE__*/ -React.createElement("div", null); +_reactJsxRuntime.jsx("div", {}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/input.js new file mode 100644 index 000000000000..6b8761b4a90a --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/input.js @@ -0,0 +1,3 @@ +/* @jsx h */ + +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/options.json new file mode 100644 index 000000000000..1eb39754fc94 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pure": true, "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment/options.json index c9f1fc61d318..b5ce0c6f2451 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-comment/options.json @@ -1,5 +1,6 @@ { "plugins": [ ["transform-react-jsx", { "pure": true }] - ] + ], + "throws": "pragma and pragmaFrag cannot be set when runtime is automatic." } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/input.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/input.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/options.json new file mode 100644 index 000000000000..4c12140e4350 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pragma": "h", "pure": true, "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option/options.json index 8d4223a48bf5..02ae74af0ecd 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/true-pragma-option/options.json @@ -1,5 +1,6 @@ { "plugins": [ ["transform-react-jsx", { "pragma": "h", "pure": true }] - ] + ], + "throws": "pragma and pragmaFrag cannot be set when runtime is automatic." } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/input.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/input.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/options.json new file mode 100644 index 000000000000..d21f1136dea5 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/output.js new file mode 100644 index 000000000000..6ad0513bb203 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma-classic-runtime/output.js @@ -0,0 +1,2 @@ +/*#__PURE__*/ +React.createElement("div", null); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma/output.js index 6ad0513bb203..5518c29044fd 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-default-pragma/output.js @@ -1,2 +1,4 @@ +var _reactJsxRuntime = require("react/jsx-runtime"); + /*#__PURE__*/ -React.createElement("div", null); +_reactJsxRuntime.jsx("div", {}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/input.js new file mode 100644 index 000000000000..6b8761b4a90a --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/input.js @@ -0,0 +1,3 @@ +/* @jsx h */ + +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/options.json new file mode 100644 index 000000000000..d21f1136dea5 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment/options.json index c6c850168596..c9fd57ccc1ef 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-comment/options.json @@ -1,5 +1,6 @@ { "plugins": [ ["transform-react-jsx", {}] - ] + ], + "throws": "pragma and pragmaFrag cannot be set when runtime is automatic." } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/input.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/input.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/options.json new file mode 100644 index 000000000000..bb8990548203 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "pragma": "h", "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option/options.json index 46f657580a52..d42b9d0a8609 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/pure/unset-pragma-option/options.json @@ -1,5 +1,6 @@ { "plugins": [ ["transform-react-jsx", { "pragma": "h" }] - ] + ], + "throws": "pragma and pragmaFrag cannot be set when runtime is automatic." } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/adds-appropriate-newlines-when-using-spread-attribute/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/adds-appropriate-newlines-when-using-spread-attribute/output.js index bfd6ae7c13f9..b07ab7c68f78 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/adds-appropriate-newlines-when-using-spread-attribute/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/adds-appropriate-newlines-when-using-spread-attribute/output.js @@ -1,4 +1,4 @@ /*#__PURE__*/ -React.createElement(Component, babelHelpers.extends({}, props, { +React.createElement(Component, { ...props, sound: "moo" -})); +}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-comment-if-jsx-pragma-option-set/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-comment-if-jsx-pragma-option-set/options.json index 17c61ec6cf9d..778a933de4cb 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-comment-if-jsx-pragma-option-set/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-comment-if-jsx-pragma-option-set/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-react-jsx", { "pragma": "foo.bar" }]] + "plugins": [["transform-react-jsx", { "pragma": "foo.bar", "runtime": "classic" }]] } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-pragma-option/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-pragma-option/options.json index 2aae85c034a8..5db83b99f444 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-pragma-option/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/honor-custom-jsx-pragma-option/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-react-jsx", { "pragma": "dom" }]] + "plugins": [["transform-react-jsx", { "pragma": "dom", "runtime": "classic" }]] } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/options.json index 2266a21df9da..3ae00ebef35a 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/options.json @@ -2,7 +2,7 @@ "plugins": [ "external-helpers", "syntax-jsx", - "transform-react-jsx", + ["transform-react-jsx", { "runtime": "classic" }], "transform-react-display-name", "transform-arrow-functions" ] diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-add-quotes-es3/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-add-quotes-es3/options.json index 81639b17e01b..0cb674fb090d 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-add-quotes-es3/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-add-quotes-es3/options.json @@ -1,3 +1,6 @@ { - "plugins": ["transform-react-jsx", "transform-property-literals"] + "plugins": [ + ["transform-react-jsx", { "runtime": "classic" }], + "transform-property-literals" + ] } diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxattribute/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxattribute/output.js index 60f6fd9294d9..a72c88050e1f 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxattribute/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxattribute/output.js @@ -1,6 +1,6 @@ /*#__PURE__*/ React.createElement("div", { - id: "w\xF4w" + id: "wôw" }); /*#__PURE__*/ diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxtext/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxtext/output.js index 64f33c72531a..1edc53edeb27 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxtext/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-escape-xhtml-jsxtext/output.js @@ -2,7 +2,7 @@ React.createElement("div", null, "wow"); /*#__PURE__*/ -React.createElement("div", null, "w\xF4w"); +React.createElement("div", null, "wôw"); /*#__PURE__*/ React.createElement("div", null, "w & w"); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-support-xml-namespaces-if-flag/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-support-xml-namespaces-if-flag/options.json index 644fc6f6da28..390bd81516c2 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-support-xml-namespaces-if-flag/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-support-xml-namespaces-if-flag/options.json @@ -4,6 +4,7 @@ "transform-react-jsx", { "pragma": "h", + "runtime": "classic", "throwIfNamespace": false } ] diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-throw-error-namespaces-if-not-flag/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-throw-error-namespaces-if-not-flag/options.json index 426249807eb6..8264ca4f7426 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-throw-error-namespaces-if-not-flag/options.json +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/should-throw-error-namespaces-if-not-flag/options.json @@ -4,6 +4,7 @@ "transform-react-jsx", { "pragma": "h", + "runtime": "classic", "throwIfNamespace": true } ] diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-first-spread-attributes/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-first-spread-attributes/output.js index b6fe512bfda8..f3e155af3c33 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-first-spread-attributes/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-first-spread-attributes/output.js @@ -1,5 +1,5 @@ /*#__PURE__*/ -React.createElement(Component, babelHelpers.extends({}, x, { +React.createElement(Component, { ...x, y: 2, z: true -})); +}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-last-spread-attributes/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-last-spread-attributes/output.js index c1c22b02c9da..2131262e948c 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-last-spread-attributes/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-last-spread-attributes/output.js @@ -1,5 +1,6 @@ /*#__PURE__*/ -React.createElement(Component, babelHelpers.extends({ +React.createElement(Component, { y: 2, - z: true -}, x)); + z: true, + ...x +}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-middle-spread-attributes/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-middle-spread-attributes/output.js index 7d99b1a29c3d..0915d43ce0cc 100644 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-middle-spread-attributes/output.js +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/react/wraps-props-in-react-spread-for-middle-spread-attributes/output.js @@ -1,6 +1,6 @@ /*#__PURE__*/ -React.createElement(Component, babelHelpers.extends({ - y: 2 -}, x, { +React.createElement(Component, { + y: 2, + ...x, z: true -})); +}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/options.json new file mode 100644 index 000000000000..d21f1136dea5 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/options.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["transform-react-jsx", { "runtime": "classic" }] + ] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/output.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/output.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default-classic-runtime/output.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/options.json deleted file mode 100644 index 5e1d82404dd3..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/regression/pragma-frag-set-default/options.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "plugins": [ - "transform-react-jsx" - ] -} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/options.json similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/options.json rename to packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/options.json diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/output.js new file mode 100644 index 000000000000..607dafdc732b --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-automatic/output.js @@ -0,0 +1,5 @@ +var _reactJsxRuntime = require("react/jsx-runtime"); + +var x = /*#__PURE__*/_reactJsxRuntime.jsx("div", { + children: /*#__PURE__*/_reactJsxRuntime.jsx("span", {}) +}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/output.js deleted file mode 100644 index ebd8fce02e70..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/runtime/defaults-to-classic/output.js +++ /dev/null @@ -1 +0,0 @@ -var x = /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("span", null)); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment-invalid-option/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/assignment/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment-invalid-option/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/assignment/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/assignment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/assignment/output.js new file mode 100644 index 000000000000..444d75ea61dd --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/assignment/output.js @@ -0,0 +1,5 @@ +var _reactJsxRuntime = require("react/jsx-runtime"); + +var div = /*#__PURE__*/_reactJsxRuntime.jsx(Component, babelHelpers.extends({}, props, { + foo: "bar" +})); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/invalid-use-builtins-false/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/invalid-use-builtins-false/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/invalid-use-builtins-false/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/invalid-use-builtins-false/options.json new file mode 100644 index 000000000000..904faef54f38 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/invalid-use-builtins-false/options.json @@ -0,0 +1,4 @@ +{ + "plugins": [["transform-react-jsx", { "runtime": "classic", "useBuiltIns": false }]], + "throws": "transform-react-jsx: Since \"useBuiltIns\" is removed in Babel 8, you must remove it from your config.\n- Babel 8 now transforms JSX spread to object spread. If you need to transpile object spread with\n`useBuiltIns: false`, you can use the following config\n{\n \"plugins\": [\n \"@babel/plugin-transform-react-jsx\",\n [\"@babel/plugin-proposal-object-rest-spread\", { \"loose\": true, \"useBuiltIns\": false }]\n ]\n}" +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/options.json new file mode 100644 index 000000000000..472d8a40f69d --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-babel-extend/options.json @@ -0,0 +1,6 @@ +{ + "plugins": ["transform-react-jsx", ["proposal-object-rest-spread", { + "loose": true, + "useBuiltIns": false + }], "external-helpers"] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-invalid-option/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/assignment/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-invalid-option/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/assignment/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/assignment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/assignment/output.js new file mode 100644 index 000000000000..d05561223fd1 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/assignment/output.js @@ -0,0 +1,5 @@ +var _reactJsxRuntime = require("react/jsx-runtime"); + +var div = /*#__PURE__*/_reactJsxRuntime.jsx(Component, Object.assign({}, props, { + foo: "bar" +})); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-use-builtin/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-builtins-true/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-use-builtin/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-builtins-true/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-builtins-true/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-builtins-true/options.json new file mode 100644 index 000000000000..9769f31f3572 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-builtins-true/options.json @@ -0,0 +1,4 @@ +{ + "plugins": [["transform-react-jsx", { "runtime": "classic", "useBuiltIns": true }]], + "throws": "transform-react-jsx: Since \"useBuiltIns\" is removed in Babel 8, you must remove it from your config.\n- Babel 8 now transforms JSX spread to object spread. If you need to transpile object spread with\n`useBuiltIns: true`, you can use the following config\n{\n \"plugins\": [\n \"@babel/plugin-transform-react-jsx\",\n [\"@babel/plugin-proposal-object-rest-spread\", { \"loose\": true, \"useBuiltIns\": true }]\n ]\n}" +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-false/input.js similarity index 100% rename from packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment/input.js rename to packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-false/input.js diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-false/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-false/options.json new file mode 100644 index 000000000000..08c9e9670dd6 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-false/options.json @@ -0,0 +1,4 @@ +{ + "plugins": [["transform-react-jsx", { "runtime": "classic", "useSpread": false }]], + "throws": "transform-react-jsx: Since Babel 8, an inline object with spread elements is always used, and the \"useSpread\" option is no longer available. Please remove it from your config." +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-true/input.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-true/input.js new file mode 100644 index 000000000000..4caacb6aa17d --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-true/input.js @@ -0,0 +1 @@ +var div = diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-true/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-true/options.json new file mode 100644 index 000000000000..7b5dc85f9f71 --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/invalid-use-spread-true/options.json @@ -0,0 +1,4 @@ +{ + "plugins": [["transform-react-jsx", { "runtime": "classic", "useSpread": true }]], + "throws": "transform-react-jsx: Since Babel 8, an inline object with spread elements is always used, and the \"useSpread\" option is no longer available. Please remove it from your config." +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/options.json new file mode 100644 index 000000000000..8a8e736aebcb --- /dev/null +++ b/packages/babel-plugin-transform-react-jsx/test/fixtures/transform-to-object-assign/options.json @@ -0,0 +1,6 @@ +{ + "plugins": ["transform-react-jsx", ["proposal-object-rest-spread", { + "loose": true, + "useBuiltIns": true + }]] +} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment-invalid-option/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment-invalid-option/options.json deleted file mode 100644 index 3baf37938e7d..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment-invalid-option/options.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "plugins": [["transform-react-jsx", { "useBuiltIns": "invalidOption" }]], - "throws": "transform-react-jsx currently only accepts a boolean option for useBuiltIns (defaults to false)" -} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment/output.js deleted file mode 100644 index a4005fba7aeb..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/assignment/output.js +++ /dev/null @@ -1,3 +0,0 @@ -var div = /*#__PURE__*/React.createElement(Component, Object.assign({}, props, { - foo: "bar" -})); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/options.json deleted file mode 100644 index 2404117dccce..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useBuiltIns/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-react-jsx", { "useBuiltIns": true }]] -} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-invalid-option/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-invalid-option/options.json deleted file mode 100644 index ff6406c9a4e2..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-invalid-option/options.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "plugins": [["transform-react-jsx", { "useSpread": 0 }]], - "throws": "transform-react-jsx currently only accepts a boolean option for useSpread (defaults to false)" -} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-use-builtin/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-use-builtin/options.json deleted file mode 100644 index eab6051daa03..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment-use-builtin/options.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "plugins": [ - ["transform-react-jsx", { "useSpread": true, "useBuiltIns": true }] - ], - "throws": "transform-react-jsx currently only accepts useBuiltIns or useSpread but not both" -} diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment/output.js b/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment/output.js deleted file mode 100644 index 0c5b1f75b073..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/assignment/output.js +++ /dev/null @@ -1,3 +0,0 @@ -var div = /*#__PURE__*/React.createElement(Component, { ...props, - foo: "bar" -}); diff --git a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/options.json b/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/options.json deleted file mode 100644 index 7e0d5fcba0f3..000000000000 --- a/packages/babel-plugin-transform-react-jsx/test/fixtures/useSpread/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-react-jsx", { "useSpread": true }]] -} diff --git a/packages/babel-plugin-transform-regenerator/test/fixtures/scope/8525/options.json b/packages/babel-plugin-transform-regenerator/test/fixtures/scope/8525/options.json index 1cb51ff34f02..94b653035559 100644 --- a/packages/babel-plugin-transform-regenerator/test/fixtures/scope/8525/options.json +++ b/packages/babel-plugin-transform-regenerator/test/fixtures/scope/8525/options.json @@ -1,4 +1,6 @@ { - "presets": ["react"], + "presets": [ + ["react", { "runtime": "classic" }] + ], "plugins": ["transform-regenerator"] } diff --git a/packages/babel-plugin-transform-runtime/package.json b/packages/babel-plugin-transform-runtime/package.json index a37b8553090c..7367a637f58b 100644 --- a/packages/babel-plugin-transform-runtime/package.json +++ b/packages/babel-plugin-transform-runtime/package.json @@ -22,7 +22,6 @@ "dependencies": { "@babel/helper-module-imports": "workspace:^7.12.1", "@babel/helper-plugin-utils": "workspace:^7.10.4", - "resolve": "^1.8.1", "semver": "^5.5.1" }, "peerDependencies": { @@ -37,7 +36,6 @@ "@babel/runtime": "workspace:*", "@babel/runtime-corejs3": "workspace:*", "@babel/template": "workspace:*", - "@babel/types": "workspace:*", - "make-dir": "^2.1.0" + "@babel/types": "workspace:*" } } diff --git a/packages/babel-plugin-transform-runtime/scripts/build-dist.js b/packages/babel-plugin-transform-runtime/scripts/build-dist.js index 05d4b841e7a7..48ab4757dfdb 100644 --- a/packages/babel-plugin-transform-runtime/scripts/build-dist.js +++ b/packages/babel-plugin-transform-runtime/scripts/build-dist.js @@ -2,7 +2,6 @@ const path = require("path"); const fs = require("fs"); -const makeDirSync = require("make-dir").sync; const helpers = require("@babel/helpers"); const babel = require("@babel/core"); const template = require("@babel/template"); @@ -11,34 +10,18 @@ const t = require("@babel/types"); const transformRuntime = require("../"); const runtimeVersion = require("@babel/runtime/package.json").version; -const corejs2Definitions = require("../lib/runtime-corejs2-definitions").default(); const corejs3Definitions = require("../lib/runtime-corejs3-definitions").default(); function outputFile(filePath, data) { - makeDirSync(path.dirname(filePath)); + fs.mkdirSync(path.dirname(filePath), { recursive: true }); fs.writeFileSync(filePath, data); } writeHelpers("@babel/runtime"); -writeHelpers("@babel/runtime-corejs2", { corejs: 2 }); writeHelpers("@babel/runtime-corejs3", { corejs: { version: 3, proposals: true }, }); -writeCoreJS({ - corejs: 2, - proposals: true, - definitions: corejs2Definitions, - paths: [ - "is-iterable", - "get-iterator", - // This was previously in definitions, but was removed to work around - // zloirock/core-js#262. We need to keep it in @babel/runtime-corejs2 to - // avoid a breaking change there. - "symbol/async-iterator", - ], - corejsRoot: "core-js/library/fn", -}); writeCoreJS({ corejs: 3, proposals: false, diff --git a/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.js b/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.js index 911d8e719bc2..c7a9c09d9228 100644 --- a/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.js +++ b/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.js @@ -1,5 +1,4 @@ import path from "path"; -import resolve from "resolve"; export default function (moduleName, dirname, absoluteRuntime) { if (absoluteRuntime === false) return moduleName; @@ -13,7 +12,9 @@ export default function (moduleName, dirname, absoluteRuntime) { function resolveAbsoluteRuntime(moduleName: string, dirname: string) { try { return path - .dirname(resolve.sync(`${moduleName}/package.json`, { basedir: dirname })) + .dirname( + require.resolve(`${moduleName}/package.json`, { paths: [dirname] }), + ) .replace(/\\/g, "/"); } catch (err) { if (err.code !== "MODULE_NOT_FOUND") throw err; diff --git a/packages/babel-plugin-transform-runtime/src/index.js b/packages/babel-plugin-transform-runtime/src/index.js index 12c1a20b889d..b20199b8f38a 100644 --- a/packages/babel-plugin-transform-runtime/src/index.js +++ b/packages/babel-plugin-transform-runtime/src/index.js @@ -2,7 +2,6 @@ import { declare } from "@babel/helper-plugin-utils"; import { addDefault, isModule } from "@babel/helper-module-imports"; import { types as t } from "@babel/core"; -import getCoreJS2Definitions from "./runtime-corejs2-definitions"; import getCoreJS3Definitions from "./runtime-corejs3-definitions"; import { typeAnnotationToString } from "./helpers"; import getRuntimePath from "./get-runtime-path"; @@ -35,17 +34,26 @@ export default declare((api, options, dirname) => { const corejsVersion = rawVersion ? Number(rawVersion) : false; - if (![false, 2, 3].includes(corejsVersion)) { + if (corejsVersion === 2) { throw new Error( - `The \`core-js\` version must be false, 2 or 3, but got ${JSON.stringify( + `Since Babel 8, the core-js 2 support has been dropped. Please use 'corejs: 3'. +- If you really want to use obsolete core-js@2, please install \`babel-plugin-polyfill-corejs2\` and add to the "plugins" config + npm install --save-dev babel-plugin-polyfill-corejs2 + yarn add --dev babel-plugin-polyfill-corejs2`, + ); + } + + if (![false, 3].includes(corejsVersion)) { + throw new Error( + `The \`core-js\` version must be false or 3, but got ${JSON.stringify( rawVersion, )}.`, ); } - if (proposals && (!corejsVersion || corejsVersion < 3)) { + if (proposals && !corejsVersion) { throw new Error( - "The 'proposals' option is only supported when using 'corejs: 3'", + "The 'proposals' option is only supported when using core-js", ); } @@ -158,21 +166,17 @@ export default declare((api, options, dirname) => { const esModules = useESModules === "auto" ? api.caller(supportsStaticESM) : useESModules; - const injectCoreJS2 = corejsVersion === 2; - const injectCoreJS3 = corejsVersion === 3; const injectCoreJS = corejsVersion !== false; - const moduleName = injectCoreJS3 - ? "@babel/runtime-corejs3" - : injectCoreJS2 - ? "@babel/runtime-corejs2" - : "@babel/runtime"; + const moduleName = injectCoreJS ? "@babel/runtime-corejs3" : "@babel/runtime"; - const corejsRoot = injectCoreJS3 && !proposals ? "core-js-stable" : "core-js"; + const corejsRoot = injectCoreJS && !proposals ? "core-js-stable" : "core-js"; - const { BuiltIns, StaticProperties, InstanceProperties } = (injectCoreJS2 - ? getCoreJS2Definitions - : getCoreJS3Definitions)(runtimeVersion); + const { + BuiltIns, + StaticProperties, + InstanceProperties, + } = getCoreJS3Definitions(runtimeVersion); const HEADER_HELPERS = ["interopRequireWildcard", "interopRequireDefault"]; @@ -286,7 +290,7 @@ export default declare((api, options, dirname) => { ); // transform calling instance methods like `something.includes()` - if (injectCoreJS3 && !hasStaticMapping(object.name, propertyName)) { + if (injectCoreJS && !hasStaticMapping(object.name, propertyName)) { if ( hasMapping(InstanceProperties, propertyName) && maybeNeedsPolyfill( @@ -372,7 +376,6 @@ export default declare((api, options, dirname) => { // transform `something[Symbol.iterator]` to calling `getIteratorMethod(something)` helper if ( - !injectCoreJS2 && node.computed && path.get("property").matchesPattern("Symbol.iterator") ) { @@ -400,7 +403,6 @@ export default declare((api, options, dirname) => { ) { // transform getting of instance methods like `method = something.includes` if ( - injectCoreJS3 && hasMapping(InstanceProperties, propertyName) && maybeNeedsPolyfill(path, InstanceProperties, propertyName) ) { diff --git a/packages/babel-plugin-transform-runtime/src/runtime-corejs2-definitions.js b/packages/babel-plugin-transform-runtime/src/runtime-corejs2-definitions.js deleted file mode 100644 index c65df3f4ee8d..000000000000 --- a/packages/babel-plugin-transform-runtime/src/runtime-corejs2-definitions.js +++ /dev/null @@ -1,155 +0,0 @@ -import { hasMinVersion } from "./helpers"; - -export default runtimeVersion => { - // Conditionally include 'Math' because it was not included in the 7.0.0 - // release of '@babel/runtime'. See issue https://github.com/babel/babel/pull/8616. - const includeMathModule = hasMinVersion("7.0.1", runtimeVersion); - - return { - BuiltIns: { - Symbol: { stable: true, path: "symbol" }, - Promise: { stable: true, path: "promise" }, - Map: { stable: true, path: "map" }, - WeakMap: { stable: true, path: "weak-map" }, - Set: { stable: true, path: "set" }, - WeakSet: { stable: true, path: "weak-set" }, - setImmediate: { stable: true, path: "set-immediate" }, - clearImmediate: { stable: true, path: "clear-immediate" }, - parseFloat: { stable: true, path: "parse-float" }, - parseInt: { stable: true, path: "parse-int" }, - }, - - StaticProperties: { - Array: { - from: { stable: true, path: "array/from" }, - isArray: { stable: true, path: "array/is-array" }, - of: { stable: true, path: "array/of" }, - }, - - JSON: { - stringify: { stable: true, path: "json/stringify" }, - }, - - Object: { - assign: { stable: true, path: "object/assign" }, - create: { stable: true, path: "object/create" }, - defineProperties: { stable: true, path: "object/define-properties" }, - defineProperty: { stable: true, path: "object/define-property" }, - entries: { stable: true, path: "object/entries" }, - freeze: { stable: true, path: "object/freeze" }, - getOwnPropertyDescriptor: { - stable: true, - path: "object/get-own-property-descriptor", - }, - getOwnPropertyDescriptors: { - stable: true, - path: "object/get-own-property-descriptors", - }, - getOwnPropertyNames: { - stable: true, - path: "object/get-own-property-names", - }, - getOwnPropertySymbols: { - stable: true, - path: "object/get-own-property-symbols", - }, - getPrototypeOf: { stable: true, path: "object/get-prototype-of" }, - isExtensible: { stable: true, path: "object/is-extensible" }, - isFrozen: { stable: true, path: "object/is-frozen" }, - isSealed: { stable: true, path: "object/is-sealed" }, - is: { stable: true, path: "object/is" }, - keys: { stable: true, path: "object/keys" }, - preventExtensions: { stable: true, path: "object/prevent-extensions" }, - seal: { stable: true, path: "object/seal" }, - setPrototypeOf: { stable: true, path: "object/set-prototype-of" }, - values: { stable: true, path: "object/values" }, - }, - - ...(includeMathModule - ? { - Math: { - acosh: { stable: true, path: "math/acosh" }, - asinh: { stable: true, path: "math/asinh" }, - atanh: { stable: true, path: "math/atanh" }, - cbrt: { stable: true, path: "math/cbrt" }, - clz32: { stable: true, path: "math/clz32" }, - cosh: { stable: true, path: "math/cosh" }, - expm1: { stable: true, path: "math/expm1" }, - fround: { stable: true, path: "math/fround" }, - hypot: { stable: true, path: "math/hypot" }, - imul: { stable: true, path: "math/imul" }, - log10: { stable: true, path: "math/log10" }, - log1p: { stable: true, path: "math/log1p" }, - log2: { stable: true, path: "math/log2" }, - sign: { stable: true, path: "math/sign" }, - sinh: { stable: true, path: "math/sinh" }, - tanh: { stable: true, path: "math/tanh" }, - trunc: { stable: true, path: "math/trunc" }, - }, - } - : {}), - - Symbol: { - // FIXME: Disabled to work around zloirock/core-js#262. - // asyncIterator: { stable: true, path: "symbol/async-iterator" }, - for: { stable: true, path: "symbol/for" }, - hasInstance: { stable: true, path: "symbol/has-instance" }, - isConcatSpreadable: { - stable: true, - path: "symbol/is-concat-spreadable", - }, - iterator: { stable: true, path: "symbol/iterator" }, - keyFor: { stable: true, path: "symbol/key-for" }, - match: { stable: true, path: "symbol/match" }, - replace: { stable: true, path: "symbol/replace" }, - search: { stable: true, path: "symbol/search" }, - species: { stable: true, path: "symbol/species" }, - split: { stable: true, path: "symbol/split" }, - toPrimitive: { stable: true, path: "symbol/to-primitive" }, - toStringTag: { stable: true, path: "symbol/to-string-tag" }, - unscopables: { stable: true, path: "symbol/unscopables" }, - }, - - String: { - at: { stable: true, path: "string/at" }, - fromCodePoint: { stable: true, path: "string/from-code-point" }, - raw: { stable: true, path: "string/raw" }, - }, - - Number: { - EPSILON: { stable: true, path: "number/epsilon" }, - isFinite: { stable: true, path: "number/is-finite" }, - isInteger: { stable: true, path: "number/is-integer" }, - isNaN: { stable: true, path: "number/is-nan" }, - isSafeInteger: { stable: true, path: "number/is-safe-integer" }, - MAX_SAFE_INTEGER: { stable: true, path: "number/max-safe-integer" }, - MIN_SAFE_INTEGER: { stable: true, path: "number/min-safe-integer" }, - parseFloat: { stable: true, path: "number/parse-float" }, - parseInt: { stable: true, path: "number/parse-int" }, - }, - - Reflect: { - apply: { stable: true, path: "reflect/apply" }, - construct: { stable: true, path: "reflect/construct" }, - defineProperty: { stable: true, path: "reflect/define-property" }, - deleteProperty: { stable: true, path: "reflect/delete-property" }, - getOwnPropertyDescriptor: { - stable: true, - path: "reflect/get-own-property-descriptor", - }, - getPrototypeOf: { stable: true, path: "reflect/get-prototype-of" }, - get: { stable: true, path: "reflect/get" }, - has: { stable: true, path: "reflect/has" }, - isExtensible: { stable: true, path: "reflect/is-extensible" }, - ownKeys: { stable: true, path: "reflect/own-keys" }, - preventExtensions: { stable: true, path: "reflect/prevent-extensions" }, - setPrototypeOf: { stable: true, path: "reflect/set-prototype-of" }, - set: { stable: true, path: "reflect/set" }, - }, - - Date: { - now: { stable: true, path: "date/now" }, - }, - }, - }; -}; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-proposals/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-proposals/output.js index 7e7c2b7b5559..6ce2d805f7b2 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-proposals/output.js +++ b/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-proposals/output.js @@ -1,6 +1,6 @@ -var _regeneratorRuntime = require("/node_modules/@babel/runtime-corejs3/regenerator"); +var _regeneratorRuntime = require("/packages/babel-runtime-corejs3/regenerator"); -var _mapInstanceProperty = require("/node_modules/@babel/runtime-corejs3/core-js/instance/map"); +var _mapInstanceProperty = require("/packages/babel-runtime-corejs3/core-js/instance/map"); var _marked = /*#__PURE__*/_regeneratorRuntime.mark(makeIterator); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-stable/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-stable/output.js index 923997b7ffd5..436be8baaefe 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-stable/output.js +++ b/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true-corejs3-stable/output.js @@ -1,6 +1,6 @@ -var _regeneratorRuntime = require("/node_modules/@babel/runtime-corejs3/regenerator"); +var _regeneratorRuntime = require("/packages/babel-runtime-corejs3/regenerator"); -var _mapInstanceProperty = require("/node_modules/@babel/runtime-corejs3/core-js-stable/instance/map"); +var _mapInstanceProperty = require("/packages/babel-runtime-corejs3/core-js-stable/instance/map"); var _marked = /*#__PURE__*/_regeneratorRuntime.mark(makeIterator); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true/output.js index e783188c9e48..e1b6927ae714 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true/output.js +++ b/packages/babel-plugin-transform-runtime/test/fixtures/absoluteRuntime/true/output.js @@ -1,4 +1,4 @@ -var _classCallCheck = require("/packages/babel-plugin-transform-runtime/node_modules/@babel/runtime/helpers/classCallCheck"); +var _classCallCheck = require("/packages/babel-runtime/helpers/classCallCheck"); let Foo = function Foo() { "use strict"; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/input.js deleted file mode 100644 index b7c61b92b0ee..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/input.js +++ /dev/null @@ -1,7 +0,0 @@ -obj.constructor === Object; -obj.constructor === Promise; - -Symbol(); -Symbol("test"); - -new Map(); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/output.js deleted file mode 100644 index 4e753ff15d6f..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/aliased-constructors/output.js +++ /dev/null @@ -1,14 +0,0 @@ -var _Map = require("@babel/runtime-corejs2/core-js/map"); - -var _Symbol = require("@babel/runtime-corejs2/core-js/symbol"); - -var _Promise = require("@babel/runtime-corejs2/core-js/promise"); - -obj.constructor === Object; -obj.constructor === _Promise; - -_Symbol(); - -_Symbol("test"); - -new _Map(); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/input.js deleted file mode 100644 index 8e9b31529424..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/input.js +++ /dev/null @@ -1 +0,0 @@ -Promise.resolve; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/output.js deleted file mode 100644 index de4a16bd915b..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/catch-all/output.js +++ /dev/null @@ -1,3 +0,0 @@ -var _Promise = require("@babel/runtime-corejs2/core-js/promise"); - -_Promise.resolve; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/input.js deleted file mode 100644 index 4e6a6de65314..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/input.js +++ /dev/null @@ -1 +0,0 @@ -class Foo {} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/options.json deleted file mode 100644 index 2972db7d1a72..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-classes"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/output.js deleted file mode 100644 index 132a249e9768..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/class/output.js +++ /dev/null @@ -1,7 +0,0 @@ -var _classCallCheck = require("@babel/runtime-corejs2/helpers/classCallCheck"); - -let Foo = function Foo() { - "use strict"; - - _classCallCheck(this, Foo); -}; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/input.js deleted file mode 100644 index 48e5f59b2c6b..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/input.js +++ /dev/null @@ -1,3 +0,0 @@ -for (var i of arr) { - -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/options.json deleted file mode 100644 index a855e9bdf376..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/options.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "plugins": [ - "transform-for-of", - ["transform-runtime", { "corejs": 2, "version": "7.100.0" }] - ] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/output.js deleted file mode 100644 index ad7039a8ea59..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/es6-for-of/output.js +++ /dev/null @@ -1,14 +0,0 @@ -var _createForOfIteratorHelper = require("@babel/runtime-corejs2/helpers/createForOfIteratorHelper"); - -var _iterator = _createForOfIteratorHelper(arr), - _step; - -try { - for (_iterator.s(); !(_step = _iterator.n()).done;) { - var i = _step.value; - } -} catch (err) { - _iterator.e(err); -} finally { - _iterator.f(); -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/input.js deleted file mode 100644 index 6968e9a2729b..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/input.js +++ /dev/null @@ -1,5 +0,0 @@ -var _isArray = "isArray"; - -Array["from"]; // polyfill -Array[_isArray]; // polyfill -Array[of]; // don't polyfill diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/options.json deleted file mode 100644 index 3514ed63b409..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }]] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/output.js deleted file mode 100644 index 59868c6f60d5..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/evaluated-static-methods/output.js +++ /dev/null @@ -1,10 +0,0 @@ -var _Array$isArray = require("@babel/runtime-corejs2/core-js/array/is-array"); - -var _Array$from = require("@babel/runtime-corejs2/core-js/array/from"); - -var _isArray = "isArray"; -_Array$from; // polyfill - -_Array$isArray; // polyfill - -Array[of]; // don't polyfill diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/input.mjs b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/input.mjs deleted file mode 100644 index 0340999129f1..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/input.mjs +++ /dev/null @@ -1,9 +0,0 @@ -import foo, * as bar from "someModule"; - -export const myWord = Symbol("abc"); -export function* giveWord () { - yield myWord; -} - -foo; -bar; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/output.mjs b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/output.mjs deleted file mode 100644 index a3ccbb960734..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/full/output.mjs +++ /dev/null @@ -1,22 +0,0 @@ -import _regeneratorRuntime from "@babel/runtime-corejs2/regenerator"; -import _Symbol from "@babel/runtime-corejs2/core-js/symbol"; - -var _marked = /*#__PURE__*/_regeneratorRuntime.mark(giveWord); - -import foo, * as bar from "someModule"; -export const myWord = _Symbol("abc"); -export function giveWord() { - return _regeneratorRuntime.wrap(function giveWord$(_context) { - while (1) switch (_context.prev = _context.next) { - case 0: - _context.next = 2; - return myWord; - - case 2: - case "end": - return _context.stop(); - } - }, _marked); -} -foo; -bar; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/input.js deleted file mode 100644 index 0ca5137f3896..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/input.js +++ /dev/null @@ -1 +0,0 @@ -bar[filter]() diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/output.js deleted file mode 100644 index fcaaf3063d97..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/instance-computed/output.js +++ /dev/null @@ -1 +0,0 @@ -bar[filter](); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/input.js deleted file mode 100644 index 5355a96916ad..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/input.js +++ /dev/null @@ -1,33 +0,0 @@ -Math.acosh; - -Math.asinh; - -Math.atanh; - -Math.cbrt; - -Math.clz32; - -Math.cosh; - -Math.expm1; - -Math.fround; - -Math.hypot; - -Math.imul; - -Math.log10; - -Math.log1p; - -Math.log2; - -Math.sign; - -Math.sinh; - -Math.tanh; - -Math.trunc; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/options.json deleted file mode 100644 index 8f919429fac3..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/options.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "plugins": [ - [ - "transform-runtime", - { - "corejs": 2 - } - ], - "transform-regenerator" - ] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/output.js deleted file mode 100644 index 4c905ed110dc..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math-undefined-version/output.js +++ /dev/null @@ -1,17 +0,0 @@ -Math.acosh; -Math.asinh; -Math.atanh; -Math.cbrt; -Math.clz32; -Math.cosh; -Math.expm1; -Math.fround; -Math.hypot; -Math.imul; -Math.log10; -Math.log1p; -Math.log2; -Math.sign; -Math.sinh; -Math.tanh; -Math.trunc; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/input.js deleted file mode 100644 index 5355a96916ad..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/input.js +++ /dev/null @@ -1,33 +0,0 @@ -Math.acosh; - -Math.asinh; - -Math.atanh; - -Math.cbrt; - -Math.clz32; - -Math.cosh; - -Math.expm1; - -Math.fround; - -Math.hypot; - -Math.imul; - -Math.log10; - -Math.log1p; - -Math.log2; - -Math.sign; - -Math.sinh; - -Math.tanh; - -Math.trunc; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/options.json deleted file mode 100644 index fdced378cb30..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "plugins": [ - [ - "transform-runtime", - { - "corejs": 2, - "version": "^7.0.2" - } - ], - "transform-regenerator" - ] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/output.js deleted file mode 100644 index 7b773a5ec2fe..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/math/output.js +++ /dev/null @@ -1,51 +0,0 @@ -var _Math$trunc = require("@babel/runtime-corejs2/core-js/math/trunc"); - -var _Math$tanh = require("@babel/runtime-corejs2/core-js/math/tanh"); - -var _Math$sinh = require("@babel/runtime-corejs2/core-js/math/sinh"); - -var _Math$sign = require("@babel/runtime-corejs2/core-js/math/sign"); - -var _Math$log2 = require("@babel/runtime-corejs2/core-js/math/log2"); - -var _Math$log1p = require("@babel/runtime-corejs2/core-js/math/log1p"); - -var _Math$log = require("@babel/runtime-corejs2/core-js/math/log10"); - -var _Math$imul = require("@babel/runtime-corejs2/core-js/math/imul"); - -var _Math$hypot = require("@babel/runtime-corejs2/core-js/math/hypot"); - -var _Math$fround = require("@babel/runtime-corejs2/core-js/math/fround"); - -var _Math$expm = require("@babel/runtime-corejs2/core-js/math/expm1"); - -var _Math$cosh = require("@babel/runtime-corejs2/core-js/math/cosh"); - -var _Math$clz = require("@babel/runtime-corejs2/core-js/math/clz32"); - -var _Math$cbrt = require("@babel/runtime-corejs2/core-js/math/cbrt"); - -var _Math$atanh = require("@babel/runtime-corejs2/core-js/math/atanh"); - -var _Math$asinh = require("@babel/runtime-corejs2/core-js/math/asinh"); - -var _Math$acosh = require("@babel/runtime-corejs2/core-js/math/acosh"); - -_Math$acosh; -_Math$asinh; -_Math$atanh; -_Math$cbrt; -_Math$clz; -_Math$cosh; -_Math$expm; -_Math$fround; -_Math$hypot; -_Math$imul; -_Math$log; -_Math$log1p; -_Math$log2; -_Math$sign; -_Math$sinh; -_Math$tanh; -_Math$trunc; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/input.mjs b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/input.mjs deleted file mode 100644 index 368b10631035..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/input.mjs +++ /dev/null @@ -1,5 +0,0 @@ -import foo from "foo"; - -class Example { - method() {} -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/options.json deleted file mode 100644 index 5d178b7e91e5..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/options.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "plugins": [ - ["transform-runtime", { "corejs": 2 }], - "transform-modules-commonjs", - "transform-classes" - ] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/output.js deleted file mode 100644 index a76fee64666b..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules-helpers/output.js +++ /dev/null @@ -1,21 +0,0 @@ -"use strict"; - -var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault"); - -var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck")); - -var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass")); - -var _foo = _interopRequireDefault(require("foo")); - -let Example = /*#__PURE__*/function () { - function Example() { - (0, _classCallCheck2.default)(this, Example); - } - - (0, _createClass2.default)(Example, [{ - key: "method", - value: function method() {} - }]); - return Example; -}(); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/input.mjs b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/input.mjs deleted file mode 100644 index ce4c7df806a2..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/input.mjs +++ /dev/null @@ -1,4 +0,0 @@ -import foo from "bar"; -foo; - -export * from "mod"; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/options.json deleted file mode 100644 index b1cff64aeeb1..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/options.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "plugins": [ - ["transform-runtime", { "corejs": 2 }], - "transform-modules-commonjs" - ] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/output.js deleted file mode 100644 index 061601e92166..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/modules/output.js +++ /dev/null @@ -1,29 +0,0 @@ -"use strict"; - -var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault"); - -var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys"); - -var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property"); - -_Object$defineProperty(exports, "__esModule", { - value: true -}); - -var _bar = _interopRequireDefault(require("bar")); - -var _mod = require("mod"); - -_Object$keys(_mod).forEach(function (key) { - if (key === "default" || key === "__esModule") return; - if (key in exports && exports[key] === _mod[key]) return; - - _Object$defineProperty(exports, key, { - enumerable: true, - get: function () { - return _mod[key]; - } - }); -}); - -_bar.default; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/input.js deleted file mode 100644 index 4e6a6de65314..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/input.js +++ /dev/null @@ -1 +0,0 @@ -class Foo {} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/options.json deleted file mode 100644 index aaf9a14cac82..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/options.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "plugins": [ - ["transform-runtime", { "helpers": false, "corejs": 2 }], - "transform-classes" - ] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/output.js deleted file mode 100644 index b8dfb3198372..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/no-helpers/output.js +++ /dev/null @@ -1,7 +0,0 @@ -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -let Foo = function Foo() { - "use strict"; - - _classCallCheck(this, Foo); -}; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/input.js deleted file mode 100644 index ae6cc4d8c8f1..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/input.js +++ /dev/null @@ -1,2 +0,0 @@ -void function* () { -}; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/output.js deleted file mode 100644 index f7e6f94493fe..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/regenerator-runtime/output.js +++ /dev/null @@ -1,11 +0,0 @@ -var _regeneratorRuntime = require("@babel/runtime-corejs2/regenerator"); - -void /*#__PURE__*/_regeneratorRuntime.mark(function _callee() { - return _regeneratorRuntime.wrap(function _callee$(_context) { - while (1) switch (_context.prev = _context.next) { - case 0: - case "end": - return _context.stop(); - } - }, _callee); -}); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/input.js deleted file mode 100644 index 49e71aa52d70..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/input.js +++ /dev/null @@ -1 +0,0 @@ -Symbol.iterator in Object(arr); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/output.js deleted file mode 100644 index 8d5e3c048d4f..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator-in/output.js +++ /dev/null @@ -1,3 +0,0 @@ -var _isIterable = require("@babel/runtime-corejs2/core-js/is-iterable"); - -_isIterable(Object(arr)); diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/input.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/input.js deleted file mode 100644 index ae1f0b9df59b..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/input.js +++ /dev/null @@ -1 +0,0 @@ -Symbol.iterator; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/options.json deleted file mode 100644 index 5c04c7763001..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-regenerator"] -} diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/output.js deleted file mode 100644 index dc708b45cc42..000000000000 --- a/packages/babel-plugin-transform-runtime/test/fixtures/runtime-corejs2/symbol-iterator/output.js +++ /dev/null @@ -1,3 +0,0 @@ -var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator"); - -_Symbol$iterator; diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/options.json index 63e7c90646fa..16df3f795223 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/options.json +++ b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/options.json @@ -1,6 +1,6 @@ { "plugins": [ - ["transform-runtime", { "corejs": 2, "useESModules": true }], + ["transform-runtime", { "corejs": 3, "useESModules": true }], "transform-classes" ] } diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/output.mjs b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/output.mjs index ce15b2059cbd..fbcd29623ef2 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/output.mjs +++ b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs-useES6Modules/output.mjs @@ -1,8 +1,8 @@ -import _Reflect$construct from "@babel/runtime-corejs2/core-js/reflect/construct"; -import _classCallCheck from "@babel/runtime-corejs2/helpers/esm/classCallCheck"; -import _inherits from "@babel/runtime-corejs2/helpers/esm/inherits"; -import _possibleConstructorReturn from "@babel/runtime-corejs2/helpers/esm/possibleConstructorReturn"; -import _getPrototypeOf from "@babel/runtime-corejs2/helpers/esm/getPrototypeOf"; +import _Reflect$construct from "@babel/runtime-corejs3/core-js-stable/reflect/construct"; +import _classCallCheck from "@babel/runtime-corejs3/helpers/esm/classCallCheck"; +import _inherits from "@babel/runtime-corejs3/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime-corejs3/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime-corejs3/helpers/esm/getPrototypeOf"; function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/options.json b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/options.json index 2972db7d1a72..e7b25dd45e31 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/options.json +++ b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-runtime", { "corejs": 2 }], "transform-classes"] + "plugins": [["transform-runtime", { "corejs": 3 }], "transform-classes"] } diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/output.mjs b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/output.mjs index ccbb71ba8094..674a80ebfaff 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/output.mjs +++ b/packages/babel-plugin-transform-runtime/test/fixtures/use-options/corejs/output.mjs @@ -1,8 +1,8 @@ -import _Reflect$construct from "@babel/runtime-corejs2/core-js/reflect/construct"; -import _classCallCheck from "@babel/runtime-corejs2/helpers/classCallCheck"; -import _inherits from "@babel/runtime-corejs2/helpers/inherits"; -import _possibleConstructorReturn from "@babel/runtime-corejs2/helpers/possibleConstructorReturn"; -import _getPrototypeOf from "@babel/runtime-corejs2/helpers/getPrototypeOf"; +import _Reflect$construct from "@babel/runtime-corejs3/core-js-stable/reflect/construct"; +import _classCallCheck from "@babel/runtime-corejs3/helpers/classCallCheck"; +import _inherits from "@babel/runtime-corejs3/helpers/inherits"; +import _possibleConstructorReturn from "@babel/runtime-corejs3/helpers/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime-corejs3/helpers/getPrototypeOf"; function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } diff --git a/packages/babel-plugin-transform-runtime/test/fixtures/windows/absoluteRuntime/output.js b/packages/babel-plugin-transform-runtime/test/fixtures/windows/absoluteRuntime/output.js index 323f1271c204..dded9de0698a 100644 --- a/packages/babel-plugin-transform-runtime/test/fixtures/windows/absoluteRuntime/output.js +++ b/packages/babel-plugin-transform-runtime/test/fixtures/windows/absoluteRuntime/output.js @@ -1,4 +1,4 @@ -var _asyncToGenerator = require("/packages/babel-plugin-transform-runtime/node_modules/@babel/runtime/helpers/asyncToGenerator"); +var _asyncToGenerator = require("/packages/babel-runtime/helpers/asyncToGenerator"); function test() { return _test.apply(this, arguments); diff --git a/packages/babel-plugin-transform-template-literals/test/fixtures/default/order/options.json b/packages/babel-plugin-transform-template-literals/test/fixtures/default/order/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-transform-template-literals/test/fixtures/default/order/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-transform-template-literals/test/fixtures/default/order2/options.json b/packages/babel-plugin-transform-template-literals/test/fixtures/default/order2/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-transform-template-literals/test/fixtures/default/order2/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-transform-template-literals/test/fixtures/default/tag-with-unicode-escapes/output.js b/packages/babel-plugin-transform-template-literals/test/fixtures/default/tag-with-unicode-escapes/output.js index 81e26c19e16a..b34f3402c5f2 100644 --- a/packages/babel-plugin-transform-template-literals/test/fixtures/default/tag-with-unicode-escapes/output.js +++ b/packages/babel-plugin-transform-template-literals/test/fixtures/default/tag-with-unicode-escapes/output.js @@ -1,5 +1,5 @@ function _templateObject() { - const data = _taggedTemplateLiteral(["aa\uD835\uDC9C\uD835\uDC9C"], ["\\u0061\\u{0061}\\ud835\\udc9c\\u{1d49c}"]); + const data = _taggedTemplateLiteral(["aa𝒜𝒜"], ["\\u0061\\u{0061}\\ud835\\udc9c\\u{1d49c}"]); _templateObject = function () { return data; diff --git a/packages/babel-plugin-transform-template-literals/test/fixtures/loose/order/options.json b/packages/babel-plugin-transform-template-literals/test/fixtures/loose/order/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-transform-template-literals/test/fixtures/loose/order/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-transform-template-literals/test/fixtures/loose/order2/options.json b/packages/babel-plugin-transform-template-literals/test/fixtures/loose/order2/options.json deleted file mode 100644 index 7d8c3c204cc8..000000000000 --- a/packages/babel-plugin-transform-template-literals/test/fixtures/loose/order2/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "minNodeVersion": "6.0.0" -} diff --git a/packages/babel-plugin-transform-typeof-symbol/package.json b/packages/babel-plugin-transform-typeof-symbol/package.json index 964ca75741d2..518efca5bed0 100644 --- a/packages/babel-plugin-transform-typeof-symbol/package.json +++ b/packages/babel-plugin-transform-typeof-symbol/package.json @@ -26,7 +26,6 @@ "@babel/helper-plugin-test-runner": "workspace:*", "@babel/runtime": "workspace:*", "@babel/runtime-corejs2": "workspace:*", - "@babel/runtime-corejs3": "workspace:*", - "resolve": "^1.15.0" + "@babel/runtime-corejs3": "workspace:*" } } diff --git a/packages/babel-plugin-transform-typeof-symbol/test/helper.spec.js b/packages/babel-plugin-transform-typeof-symbol/test/helper.spec.js index 9a89884a3c5f..7e189f130dac 100644 --- a/packages/babel-plugin-transform-typeof-symbol/test/helper.spec.js +++ b/packages/babel-plugin-transform-typeof-symbol/test/helper.spec.js @@ -1,13 +1,8 @@ import * as babel from "@babel/core"; -import resolvePath from "resolve"; import fs from "fs"; import transformTypeofSymbol from ".."; -const resolve = path => - new Promise((resolve, reject) => - resolvePath(path, (err, path) => (err ? reject(err) : resolve(path))), - ); const readFile = path => new Promise((resolve, reject) => fs.readFile(path, "utf8", (err, contents) => { @@ -21,14 +16,12 @@ describe("@babel/plugin-transform-typeof-symbol", () => { runtime | type ${"@babel/runtime"} | ${"esm"} ${"@babel/runtime"} | ${"cjs"} - ${"@babel/runtime-corejs2"} | ${"esm"} - ${"@babel/runtime-corejs2"} | ${"cjs"} ${"@babel/runtime-corejs3"} | ${"esm"} ${"@babel/runtime-corejs3"} | ${"cjs"} `( "shouldn't transpile the $type $runtime helper", async ({ type, runtime }) => { - const path = await resolve( + const path = require.resolve( `${runtime}/helpers${type === "esm" ? "/esm/" : "/"}typeof`, ); const src = await readFile(path); diff --git a/packages/babel-plugin-transform-typescript/src/index.js b/packages/babel-plugin-transform-typescript/src/index.js index 668690219a20..0c66e56bc867 100644 --- a/packages/babel-plugin-transform-typescript/src/index.js +++ b/packages/babel-plugin-transform-typescript/src/index.js @@ -52,7 +52,6 @@ export default declare( jsxPragma = "React.createElement", jsxPragmaFrag = "React.Fragment", allowNamespaces = false, - allowDeclareFields = false, onlyRemoveTypeImports = false, }, ) => { @@ -64,12 +63,6 @@ export default declare( field(path) { const { node } = path; - if (!allowDeclareFields && node.declare) { - throw path.buildCodeFrameError( - `The 'declare' modifier is only allowed when the 'allowDeclareFields' option of ` + - `@babel/plugin-transform-typescript or @babel/preset-typescript is enabled.`, - ); - } if (node.declare) { if (node.value) { throw path.buildCodeFrameError( @@ -85,18 +78,6 @@ export default declare( `Definitely assigned fields cannot be initialized here, but only in the constructor`, ); } - // keep the definitely assigned fields only when `allowDeclareFields` (equivalent of - // Typescript's `useDefineForClassFields`) is true - if (!allowDeclareFields && !node.decorators) { - path.remove(); - } - } else if ( - !allowDeclareFields && - !node.value && - !node.decorators && - !t.isClassPrivateProperty(node) - ) { - path.remove(); } if (node.accessibility) node.accessibility = null; diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-enabled/input.ts b/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-enabled/input.ts deleted file mode 100644 index 3cb9d54665fa..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-enabled/input.ts +++ /dev/null @@ -1,3 +0,0 @@ -class A { - declare x; -} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-enabled/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-enabled/options.json deleted file mode 100644 index c844b0ad736c..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-enabled/options.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "plugins": ["transform-typescript"], - "throws": "The 'declare' modifier is only allowed when the 'allowDeclareFields' option of @babel/plugin-transform-typescript or @babel/preset-typescript is enabled." -} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/options.json deleted file mode 100644 index a6d406a50e49..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-typescript", { "allowDeclareFields": true }]] -} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/declare/options.json index 1cc5b964144a..14b2876dc1cf 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/class/declare/options.json @@ -1,6 +1,3 @@ { - "plugins": [ - ["transform-typescript", { "allowDeclareFields": true }], - ["syntax-decorators", { "legacy": true }] - ] + "plugins": ["transform-typescript", ["syntax-decorators", { "legacy": true }]] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/input.ts b/packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/input.ts similarity index 100% rename from packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/input.ts rename to packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/input.ts diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/options.json new file mode 100644 index 000000000000..5c79172a6082 --- /dev/null +++ b/packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/options.json @@ -0,0 +1,3 @@ +{ + "plugins": ["transform-typescript"] +} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/output.js b/packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/output.js similarity index 100% rename from packages/babel-plugin-transform-typescript/test/fixtures/class/declare-not-initialized/output.js rename to packages/babel-plugin-transform-typescript/test/fixtures/class/field-not-initialized/output.js diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/properties/output.js b/packages/babel-plugin-transform-typescript/test/fixtures/class/properties/output.js index 139775da655a..9a3665ad3aa7 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/properties/output.js +++ b/packages/babel-plugin-transform-typescript/test/fixtures/class/properties/output.js @@ -1,10 +1,12 @@ class C { + a; b = 0; c = 1; @foo d; @foo e = 3; + f; @foo g; #h; diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare-wrong-order/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare-wrong-order/options.json index 8a07f1cc2003..bdc1d6238c8b 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare-wrong-order/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare-wrong-order/options.json @@ -1,7 +1,7 @@ { "plugins": [ "proposal-class-properties", - ["transform-typescript", { "allowDeclareFields": true }] + "transform-typescript" ], "throws": "TypeScript 'declare' fields must first be transformed by @babel/plugin-transform-typescript.\nIf you have already enabled that plugin (or '@babel/preset-typescript'), make sure that it runs before any plugin related to additional class features:\n - @babel/plugin-proposal-class-properties\n - @babel/plugin-proposal-private-methods\n - @babel/plugin-proposal-decorators" } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/input.ts b/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/input.ts deleted file mode 100644 index afc220470140..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/input.ts +++ /dev/null @@ -1,4 +0,0 @@ -class A { - declare x; - y; -} \ No newline at end of file diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/options.json deleted file mode 100644 index 832ece64097b..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/options.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "plugins": [ - ["transform-typescript", { "allowDeclareFields": true }], - "proposal-class-properties" - ] -} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/output.js b/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/output.js deleted file mode 100644 index 44b56f160013..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/transform-properties-declare/output.js +++ /dev/null @@ -1,8 +0,0 @@ -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -class A { - constructor() { - _defineProperty(this, "y", void 0); - } - -} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-disabled/output.js b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-disabled/output.js index a869c2849526..eebf5c5c33db 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-disabled/output.js +++ b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-disabled/output.js @@ -1 +1,3 @@ -class A {} +class A { + x; +} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/options.json deleted file mode 100644 index a6d406a50e49..000000000000 --- a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "plugins": [["transform-typescript", { "allowDeclareFields": true }]] -} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/input.ts b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/input.ts similarity index 100% rename from packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/input.ts rename to packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/input.ts diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/options.json new file mode 100644 index 000000000000..5c79172a6082 --- /dev/null +++ b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/options.json @@ -0,0 +1,3 @@ +{ + "plugins": ["transform-typescript"] +} diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/output.js b/packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/output.js similarity index 100% rename from packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite-with-declare-enabled/output.js rename to packages/babel-plugin-transform-typescript/test/fixtures/class/uninitialized-definite/output.js diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/input.ts b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/input.tsx similarity index 88% rename from packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/input.ts rename to packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/input.tsx index 9ba83b13ea8c..d24d345389ce 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/input.ts +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/input.tsx @@ -1,4 +1,4 @@ /* @jsx jsx.htm */ // Don't elide htm if a JSX element appears somewhere. import * as jsx from "fake-jsx-package"; -
; +(
); diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/options.json index 2c7aa7bce294..d025db8e2995 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-namespace-no/options.json @@ -1,3 +1,6 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": [ + "transform-typescript", + "syntax-jsx" + ] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-no/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-no/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-no/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragma-no/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-namespace-no/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-namespace-no/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-namespace-no/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-namespace-no/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-no/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-no/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-no/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-jsx-pragmaFrag-no/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no-2/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no-2/options.json index 7672b90ff149..52abbeaacbe7 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no-2/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no-2/options.json @@ -2,7 +2,8 @@ "plugins": [ [ "transform-typescript", - { "jsxPragma": "h", "jsxPragmaFrag": "Fragment", "isTSX": true } - ] + { "jsxPragma": "h", "jsxPragmaFrag": "Fragment" } + ], + "syntax-jsx" ] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no/options.json index 7672b90ff149..763cee6d1489 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-preact-no/options.json @@ -1,8 +1,6 @@ { "plugins": [ - [ - "transform-typescript", - { "jsxPragma": "h", "jsxPragmaFrag": "Fragment", "isTSX": true } - ] + ["transform-typescript", { "jsxPragma": "h", "jsxPragmaFrag": "Fragment" }], + "syntax-jsx" ] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-2/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-2/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-2/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-2/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-3/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-3/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-3/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no-3/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/imports/elide-react-no/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested-export/output.mjs b/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested-export/output.mjs index a3839919a8bd..7fdcf485a691 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested-export/output.mjs +++ b/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested-export/output.mjs @@ -4,7 +4,9 @@ export let src; let ns1; (function (_ns) { - class foo {} + class foo { + F1; + } _ns.foo = foo; })(ns1 || (ns1 = _src.ns1 || (_src.ns1 = {}))); @@ -12,7 +14,9 @@ export let src; let ns2; (function (_ns2) { - class foo {} + class foo { + F1; + } _ns2.foo = foo; })(ns2 || (ns2 = _src.ns2 || (_src.ns2 = {}))); diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested/output.mjs b/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested/output.mjs index 407dcf9ba825..2f6a93522467 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested/output.mjs +++ b/packages/babel-plugin-transform-typescript/test/fixtures/namespace/module-nested/output.mjs @@ -4,7 +4,9 @@ let src; let ns1; (function (_ns) { - class foo {} + class foo { + F1; + } _ns.foo = foo; })(ns1 || (ns1 = _src.ns1 || (_src.ns1 = {}))); @@ -12,7 +14,9 @@ let src; let ns2; (function (_ns2) { - class foo {} + class foo { + F1; + } _ns2.foo = foo; })(ns2 || (ns2 = _src.ns2 || (_src.ns2 = {}))); diff --git a/packages/babel-plugin-transform-typescript/test/fixtures/type-arguments/tsx/options.json b/packages/babel-plugin-transform-typescript/test/fixtures/type-arguments/tsx/options.json index 2c7aa7bce294..ecf5e3692302 100644 --- a/packages/babel-plugin-transform-typescript/test/fixtures/type-arguments/tsx/options.json +++ b/packages/babel-plugin-transform-typescript/test/fixtures/type-arguments/tsx/options.json @@ -1,3 +1,3 @@ { - "plugins": [["transform-typescript", { "isTSX": true }]] + "plugins": ["transform-typescript", "syntax-jsx"] } diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-accessor-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-accessor-key/output.js index 10938f7568ff..2dd84921c425 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-accessor-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-accessor-key/output.js @@ -1,4 +1,4 @@ var o = class { - get "\uD835\uDC9C"() {} + get "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-field-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-field-key/output.js index faf4ff2776c1..5ea816f9b76f 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-field-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-field-key/output.js @@ -1,3 +1,3 @@ var o = class { - "\uD835\uDC9C" = 1; + "𝒜" = 1; }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-method-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-method-key/output.js index fbdb2b3b3f52..44b3377dd7d7 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-method-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-class-method-key/output.js @@ -1,4 +1,4 @@ var o = class { - "\uD835\uDC9C"() {} + "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-member-property/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-member-property/output.js index 3b1f7e347692..c9e0075c47f1 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-member-property/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-member-property/output.js @@ -1 +1 @@ -obj["\uD835\uDC9C"]; +obj["𝒜"]; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-accessor-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-accessor-key/output.js index 2649ec435616..66f231e3605a 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-accessor-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-accessor-key/output.js @@ -1,4 +1,4 @@ var o = { - get "\uD835\uDC9C"() {} + get "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-method-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-method-key/output.js index 66c6a6190d88..cacf5eb85898 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-method-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-method-key/output.js @@ -1,4 +1,4 @@ var o = { - "\uD835\uDC9C"() {} + "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-key/output.js index e05fb45e13ee..b1da6a70bbf9 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-key/output.js @@ -1,3 +1,3 @@ var o = { - "\uD835\uDC9C": 1 + "𝒜": 1 }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-shorthand/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-shorthand/output.js index 3f94fa340781..d7851ae58a56 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-shorthand/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-object-property-shorthand/output.js @@ -1,4 +1,4 @@ var _ud835_udc9c = 1; var o = { - "\uD835\uDC9C": _ud835_udc9c + "𝒜": _ud835_udc9c }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-optional-member-property/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-optional-member-property/output.js index 1f07f6eba8f4..29747cea565a 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-optional-member-property/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/escaped-optional-member-property/output.js @@ -1 +1 @@ -obj?.["\uD835\uDC9C"]; +obj?.["𝒜"]; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-accessor-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-accessor-key/output.js index 10938f7568ff..2dd84921c425 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-accessor-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-accessor-key/output.js @@ -1,4 +1,4 @@ var o = class { - get "\uD835\uDC9C"() {} + get "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-field-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-field-key/output.js index faf4ff2776c1..5ea816f9b76f 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-field-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-field-key/output.js @@ -1,3 +1,3 @@ var o = class { - "\uD835\uDC9C" = 1; + "𝒜" = 1; }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-method-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-method-key/output.js index fbdb2b3b3f52..44b3377dd7d7 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-method-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-class-method-key/output.js @@ -1,4 +1,4 @@ var o = class { - "\uD835\uDC9C"() {} + "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-member-property/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-member-property/output.js index 3b1f7e347692..c9e0075c47f1 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-member-property/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-member-property/output.js @@ -1 +1 @@ -obj["\uD835\uDC9C"]; +obj["𝒜"]; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-accessor-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-accessor-key/output.js index 2649ec435616..66f231e3605a 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-accessor-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-accessor-key/output.js @@ -1,4 +1,4 @@ var o = { - get "\uD835\uDC9C"() {} + get "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-method-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-method-key/output.js index 66c6a6190d88..cacf5eb85898 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-method-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-method-key/output.js @@ -1,4 +1,4 @@ var o = { - "\uD835\uDC9C"() {} + "𝒜"() {} }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-key/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-key/output.js index e05fb45e13ee..b1da6a70bbf9 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-key/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-key/output.js @@ -1,3 +1,3 @@ var o = { - "\uD835\uDC9C": 1 + "𝒜": 1 }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-shorthand/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-shorthand/output.js index 3f94fa340781..d7851ae58a56 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-shorthand/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-object-property-shorthand/output.js @@ -1,4 +1,4 @@ var _ud835_udc9c = 1; var o = { - "\uD835\uDC9C": _ud835_udc9c + "𝒜": _ud835_udc9c }; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-optional-member-property/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-optional-member-property/output.js index 1f07f6eba8f4..29747cea565a 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-optional-member-property/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/raw-optional-member-property/output.js @@ -1 +1 @@ -obj?.["\uD835\uDC9C"]; +obj?.["𝒜"]; diff --git a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/tagged-template-transformed/output.js b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/tagged-template-transformed/output.js index 4f8fa85f21b8..44df6a97b128 100644 --- a/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/tagged-template-transformed/output.js +++ b/packages/babel-plugin-transform-unicode-escapes/test/fixtures/unicode-escapes/tagged-template-transformed/output.js @@ -9,7 +9,7 @@ function _templateObject5() { } function _templateObject4() { - const data = _taggedTemplateLiteral(["\\\uD835\uDC9C"], ["\\\\\\u{1d49c}"]); + const data = _taggedTemplateLiteral(["\\𝒜"], ["\\\\\\u{1d49c}"]); _templateObject4 = function () { return data; @@ -29,7 +29,7 @@ function _templateObject3() { } function _templateObject2() { - const data = _taggedTemplateLiteral(["\uD835\uDC9C"], ["\\u{1d49c}"]); + const data = _taggedTemplateLiteral(["𝒜"], ["\\u{1d49c}"]); _templateObject2 = function () { return data; @@ -39,7 +39,7 @@ function _templateObject2() { } function _templateObject() { - const data = _taggedTemplateLiteral(["\uD835\uDC9C\uD835\uDC9C\uD835\uDC9C"], ["\uD835\uDC9C\\ud835\\udc9c\\u{1d49c}"]); + const data = _taggedTemplateLiteral(["𝒜𝒜𝒜"], ["𝒜\\ud835\\udc9c\\u{1d49c}"]); _templateObject = function () { return data; diff --git a/packages/babel-preset-env/data/built-ins.js b/packages/babel-preset-env/data/built-ins.js deleted file mode 100644 index 38f8a09add7a..000000000000 --- a/packages/babel-preset-env/data/built-ins.js +++ /dev/null @@ -1,4 +0,0 @@ -// TODO: Remove in Babel 8 -// https://github.com/vuejs/vue-cli/issues/3671 - -module.exports = require("./corejs2-built-ins.json"); diff --git a/packages/babel-preset-env/data/built-ins.json.js b/packages/babel-preset-env/data/built-ins.json.js deleted file mode 100644 index 38f8a09add7a..000000000000 --- a/packages/babel-preset-env/data/built-ins.json.js +++ /dev/null @@ -1,4 +0,0 @@ -// TODO: Remove in Babel 8 -// https://github.com/vuejs/vue-cli/issues/3671 - -module.exports = require("./corejs2-built-ins.json"); diff --git a/packages/babel-preset-env/data/corejs2-built-ins.js b/packages/babel-preset-env/data/corejs2-built-ins.js deleted file mode 100644 index 486f3b1e1b2a..000000000000 --- a/packages/babel-preset-env/data/corejs2-built-ins.js +++ /dev/null @@ -1,3 +0,0 @@ -// TODO: Remove in Babel 8 - -module.exports = require("@babel/compat-data/corejs2-built-ins"); diff --git a/packages/babel-preset-env/data/corejs2-built-ins.json.js b/packages/babel-preset-env/data/corejs2-built-ins.json.js deleted file mode 100644 index 486f3b1e1b2a..000000000000 --- a/packages/babel-preset-env/data/corejs2-built-ins.json.js +++ /dev/null @@ -1,3 +0,0 @@ -// TODO: Remove in Babel 8 - -module.exports = require("@babel/compat-data/corejs2-built-ins"); diff --git a/packages/babel-preset-env/src/index.js b/packages/babel-preset-env/src/index.js index e3cfb7a623ce..67c6716e067f 100644 --- a/packages/babel-preset-env/src/index.js +++ b/packages/babel-preset-env/src/index.js @@ -13,10 +13,8 @@ import { } from "./plugins-compat-data"; import overlappingPlugins from "@babel/compat-data/overlapping-plugins"; -import addCoreJS2UsagePlugin from "./polyfills/corejs2/usage-plugin"; import addCoreJS3UsagePlugin from "./polyfills/corejs3/usage-plugin"; import addRegeneratorUsagePlugin from "./polyfills/regenerator/usage-plugin"; -import replaceCoreJS2EntryPlugin from "./polyfills/corejs2/entry-plugin"; import replaceCoreJS3EntryPlugin from "./polyfills/corejs3/entry-plugin"; import removeRegeneratorEntryPlugin from "./polyfills/regenerator/entry-plugin"; @@ -183,22 +181,14 @@ export const getPolyfillPlugins = ({ if (corejs) { if (useBuiltIns === "usage") { - if (corejs.major === 2) { - polyfillPlugins.push([addCoreJS2UsagePlugin, pluginOptions]); - } else { - polyfillPlugins.push([addCoreJS3UsagePlugin, pluginOptions]); - } + polyfillPlugins.push([addCoreJS3UsagePlugin, pluginOptions]); if (regenerator) { polyfillPlugins.push([addRegeneratorUsagePlugin, pluginOptions]); } } else { - if (corejs.major === 2) { - polyfillPlugins.push([replaceCoreJS2EntryPlugin, pluginOptions]); - } else { - polyfillPlugins.push([replaceCoreJS3EntryPlugin, pluginOptions]); - if (!regenerator) { - polyfillPlugins.push([removeRegeneratorEntryPlugin, pluginOptions]); - } + polyfillPlugins.push([replaceCoreJS3EntryPlugin, pluginOptions]); + if (!regenerator) { + polyfillPlugins.push([removeRegeneratorEntryPlugin, pluginOptions]); } } } @@ -242,18 +232,6 @@ export default declare((api, opts) => { corejs: { version: corejs, proposals }, browserslistEnv, } = normalizeOptions(opts); - // TODO: remove this in next major - let hasUglifyTarget = false; - - if (optionsTargets?.uglify) { - hasUglifyTarget = true; - delete optionsTargets.uglify; - - console.log(""); - console.log("The uglify target has been deprecated. Set the top level"); - console.log("option `forceAllTransforms: true` instead."); - console.log(""); - } if (optionsTargets?.esmodules && optionsTargets.browsers) { console.log(""); @@ -275,7 +253,7 @@ export default declare((api, opts) => { const include = transformIncludesAndExcludes(optionsInclude); const exclude = transformIncludesAndExcludes(optionsExclude); - const transformTargets = forceAllTransforms || hasUglifyTarget ? {} : targets; + const transformTargets = forceAllTransforms ? {} : targets; const compatData = getPluginList(shippedProposals, bugfixes); const shouldSkipExportNamespaceFrom = diff --git a/packages/babel-preset-env/src/normalize-options.js b/packages/babel-preset-env/src/normalize-options.js index 84ebf85300d0..86957360fc07 100644 --- a/packages/babel-preset-env/src/normalize-options.js +++ b/packages/babel-preset-env/src/normalize-options.js @@ -1,12 +1,10 @@ // @flow import corejs3Polyfills from "core-js-compat/data"; import { coerce, SemVer } from "semver"; -import corejs2Polyfills from "@babel/compat-data/corejs2-built-ins"; import { plugins as pluginsList } from "./plugins-compat-data"; import moduleTransformations from "./module-transformations"; import { TopLevelOptions, ModulesOption, UseBuiltInsOption } from "./options"; import { OptionValidator } from "@babel/helper-validator-option"; -import { defaultWebIncludes } from "./polyfills/corejs2/get-platform-specific-default"; import { name as packageName } from "../package.json"; import type { @@ -37,11 +35,7 @@ const getValidIncludesAndExcludes = ( new Set([ ...allPluginsList, ...(type === "exclude" ? modulePlugins : []), - ...(corejs - ? corejs == 2 - ? [...Object.keys(corejs2Polyfills), ...defaultWebIncludes] - : Object.keys(corejs3Polyfills) - : []), + ...(corejs ? Object.keys(corejs3Polyfills) : []), ]); const pluginToRegExp = (plugin: PluginListItem) => { @@ -158,10 +152,10 @@ export function normalizeCoreJSOption( let rawVersion; if (useBuiltIns && corejs === undefined) { - rawVersion = 2; + rawVersion = "3.6"; console.warn( "\nWARNING: We noticed you're using the `useBuiltIns` option without declaring a " + - "core-js version. Currently, we assume version 2.x when no version " + + "core-js version. Currently, we assume version `3.6` when no version " + "is passed. Since this default version will likely change in future " + "versions of Babel, we recommend explicitly setting the core-js version " + "you are using via the `corejs` option.\n" + @@ -169,8 +163,8 @@ export function normalizeCoreJSOption( "option matches the version specified in your `package.json`'s " + "`dependencies` section. If it doesn't, you need to run one of the " + "following commands:\n\n" + - " npm install --save core-js@2 npm install --save core-js@3\n" + - " yarn add core-js@2 yarn add core-js@3\n", + " npm install --save core-js@3.6\n" + + " yarn add core-js@3.6\n", ); } else if (typeof corejs === "object" && corejs !== null) { rawVersion = corejs.version; @@ -187,11 +181,20 @@ export function normalizeCoreJSOption( ); } - if (useBuiltIns && (!version || version.major < 2 || version.major > 3)) { - throw new RangeError( - "Invalid Option: The version passed to `corejs` is invalid. Currently, " + - "only core-js@2 and core-js@3 are supported.", - ); + if (useBuiltIns) { + if (!version || version.major < 2 || version.major > 3) { + throw new RangeError( + "Invalid Option: The version passed to `corejs` is invalid. Currently, " + + "only core-js@3 is supported.", + ); + } else if (version.major === 2) { + throw new Error( + `Since Babel 8, the core-js@2 support has been dropped. Please use \`corejs: "3.6"\`. +- If you really want to use obsolete core-js@2, please install \`babel-plugin-polyfill-corejs2\` and add to the "plugins" config + npm install --save-dev babel-plugin-polyfill-corejs2 + yarn add --dev babel-plugin-polyfill-corejs2`, + ); + } } return { version, proposals }; diff --git a/packages/babel-preset-env/src/polyfills/corejs2/built-in-definitions.js b/packages/babel-preset-env/src/polyfills/corejs2/built-in-definitions.js deleted file mode 100644 index 10ba84eb9a92..000000000000 --- a/packages/babel-preset-env/src/polyfills/corejs2/built-in-definitions.js +++ /dev/null @@ -1,190 +0,0 @@ -// @flow - -type ObjectMap = { [name: string]: V }; - -const ArrayNatureIterators = [ - "es6.object.to-string", - "es6.array.iterator", - "web.dom.iterable", -]; - -const CommonIterators = ["es6.string.iterator", ...ArrayNatureIterators]; - -const PromiseDependencies = ["es6.object.to-string", "es6.promise"]; - -export const BuiltIns: ObjectMap = { - DataView: "es6.typed.data-view", - Float32Array: "es6.typed.float32-array", - Float64Array: "es6.typed.float64-array", - Int8Array: "es6.typed.int8-array", - Int16Array: "es6.typed.int16-array", - Int32Array: "es6.typed.int32-array", - Map: ["es6.map", ...CommonIterators], - Number: "es6.number.constructor", - Promise: PromiseDependencies, - RegExp: ["es6.regexp.constructor"], - Set: ["es6.set", ...CommonIterators], - Symbol: ["es6.symbol", "es7.symbol.async-iterator"], - Uint8Array: "es6.typed.uint8-array", - Uint8ClampedArray: "es6.typed.uint8-clamped-array", - Uint16Array: "es6.typed.uint16-array", - Uint32Array: "es6.typed.uint32-array", - WeakMap: ["es6.weak-map", ...CommonIterators], - WeakSet: ["es6.weak-set", ...CommonIterators], -}; - -export const InstanceProperties: ObjectMap = { - __defineGetter__: ["es7.object.define-getter"], - __defineSetter__: ["es7.object.define-setter"], - __lookupGetter__: ["es7.object.lookup-getter"], - __lookupSetter__: ["es7.object.lookup-setter"], - anchor: ["es6.string.anchor"], - big: ["es6.string.big"], - bind: ["es6.function.bind"], - blink: ["es6.string.blink"], - bold: ["es6.string.bold"], - codePointAt: ["es6.string.code-point-at"], - copyWithin: ["es6.array.copy-within"], - endsWith: ["es6.string.ends-with"], - entries: ArrayNatureIterators, - every: ["es6.array.is-array"], - fill: ["es6.array.fill"], - filter: ["es6.array.filter"], - finally: ["es7.promise.finally", ...PromiseDependencies], - find: ["es6.array.find"], - findIndex: ["es6.array.find-index"], - fixed: ["es6.string.fixed"], - flags: ["es6.regexp.flags"], - flatMap: ["es7.array.flat-map"], - fontcolor: ["es6.string.fontcolor"], - fontsize: ["es6.string.fontsize"], - forEach: ["es6.array.for-each"], - includes: ["es6.string.includes", "es7.array.includes"], - indexOf: ["es6.array.index-of"], - italics: ["es6.string.italics"], - keys: ArrayNatureIterators, - lastIndexOf: ["es6.array.last-index-of"], - link: ["es6.string.link"], - map: ["es6.array.map"], - match: ["es6.regexp.match"], - name: ["es6.function.name"], - padStart: ["es7.string.pad-start"], - padEnd: ["es7.string.pad-end"], - reduce: ["es6.array.reduce"], - reduceRight: ["es6.array.reduce-right"], - repeat: ["es6.string.repeat"], - replace: ["es6.regexp.replace"], - search: ["es6.regexp.search"], - slice: ["es6.array.slice"], - small: ["es6.string.small"], - some: ["es6.array.some"], - sort: ["es6.array.sort"], - split: ["es6.regexp.split"], - startsWith: ["es6.string.starts-with"], - strike: ["es6.string.strike"], - sub: ["es6.string.sub"], - sup: ["es6.string.sup"], - toISOString: ["es6.date.to-iso-string"], - toJSON: ["es6.date.to-json"], - toString: [ - "es6.object.to-string", - "es6.date.to-string", - "es6.regexp.to-string", - ], - trim: ["es6.string.trim"], - trimEnd: ["es7.string.trim-right"], - trimLeft: ["es7.string.trim-left"], - trimRight: ["es7.string.trim-right"], - trimStart: ["es7.string.trim-left"], - values: ArrayNatureIterators, -}; - -export const StaticProperties: ObjectMap> = { - Array: { - from: ["es6.array.from", "es6.string.iterator"], - isArray: "es6.array.is-array", - of: "es6.array.of", - }, - - Date: { - now: "es6.date.now", - }, - - Object: { - assign: "es6.object.assign", - create: "es6.object.create", - defineProperty: "es6.object.define-property", - defineProperties: "es6.object.define-properties", - entries: "es7.object.entries", - freeze: "es6.object.freeze", - getOwnPropertyDescriptors: "es7.object.get-own-property-descriptors", - getOwnPropertySymbols: "es6.symbol", - is: "es6.object.is", - isExtensible: "es6.object.is-extensible", - isFrozen: "es6.object.is-frozen", - isSealed: "es6.object.is-sealed", - keys: "es6.object.keys", - preventExtensions: "es6.object.prevent-extensions", - seal: "es6.object.seal", - setPrototypeOf: "es6.object.set-prototype-of", - values: "es7.object.values", - }, - - Math: { - acosh: "es6.math.acosh", - asinh: "es6.math.asinh", - atanh: "es6.math.atanh", - cbrt: "es6.math.cbrt", - clz32: "es6.math.clz32", - cosh: "es6.math.cosh", - expm1: "es6.math.expm1", - fround: "es6.math.fround", - hypot: "es6.math.hypot", - imul: "es6.math.imul", - log1p: "es6.math.log1p", - log10: "es6.math.log10", - log2: "es6.math.log2", - sign: "es6.math.sign", - sinh: "es6.math.sinh", - tanh: "es6.math.tanh", - trunc: "es6.math.trunc", - }, - - String: { - fromCodePoint: "es6.string.from-code-point", - raw: "es6.string.raw", - }, - - Number: { - EPSILON: "es6.number.epsilon", - MIN_SAFE_INTEGER: "es6.number.min-safe-integer", - MAX_SAFE_INTEGER: "es6.number.max-safe-integer", - isFinite: "es6.number.is-finite", - isInteger: "es6.number.is-integer", - isSafeInteger: "es6.number.is-safe-integer", - isNaN: "es6.number.is-nan", - parseFloat: "es6.number.parse-float", - parseInt: "es6.number.parse-int", - }, - - Promise: { - all: CommonIterators, - race: CommonIterators, - }, - - Reflect: { - apply: "es6.reflect.apply", - construct: "es6.reflect.construct", - defineProperty: "es6.reflect.define-property", - deleteProperty: "es6.reflect.delete-property", - get: "es6.reflect.get", - getOwnPropertyDescriptor: "es6.reflect.get-own-property-descriptor", - getPrototypeOf: "es6.reflect.get-prototype-of", - has: "es6.reflect.has", - isExtensible: "es6.reflect.is-extensible", - ownKeys: "es6.reflect.own-keys", - preventExtensions: "es6.reflect.prevent-extensions", - set: "es6.reflect.set", - setPrototypeOf: "es6.reflect.set-prototype-of", - }, -}; diff --git a/packages/babel-preset-env/src/polyfills/corejs2/entry-plugin.js b/packages/babel-preset-env/src/polyfills/corejs2/entry-plugin.js deleted file mode 100644 index cf0f17e4644a..000000000000 --- a/packages/babel-preset-env/src/polyfills/corejs2/entry-plugin.js +++ /dev/null @@ -1,85 +0,0 @@ -// @flow - -import corejs2Polyfills from "@babel/compat-data/corejs2-built-ins"; -import { filterItems } from "@babel/helper-compilation-targets"; -import getPlatformSpecificDefaultFor from "./get-platform-specific-default"; -import { - createImport, - isPolyfillSource, - getImportSource, - getRequireSource, -} from "../../utils"; -import { logEntryPolyfills } from "../../debug"; - -import type { InternalPluginOptions } from "../../types"; -import type { NodePath } from "@babel/traverse"; - -export default function ( - _: any, - { - include, - exclude, - polyfillTargets, - regenerator, - debug, - }: InternalPluginOptions, -) { - const polyfills = filterItems( - corejs2Polyfills, - include, - exclude, - polyfillTargets, - getPlatformSpecificDefaultFor(polyfillTargets), - ); - - const isPolyfillImport = { - ImportDeclaration(path: NodePath) { - if (isPolyfillSource(getImportSource(path))) { - this.replaceBySeparateModulesImport(path); - } - }, - Program(path: NodePath) { - path.get("body").forEach(bodyPath => { - if (isPolyfillSource(getRequireSource(bodyPath))) { - this.replaceBySeparateModulesImport(bodyPath); - } - }); - }, - }; - - return { - name: "corejs2-entry", - visitor: isPolyfillImport, - pre() { - this.importPolyfillIncluded = false; - - this.replaceBySeparateModulesImport = function (path) { - this.importPolyfillIncluded = true; - - if (regenerator) { - createImport(path, "regenerator-runtime"); - } - - const modules = Array.from(polyfills).reverse(); - - for (const module of modules) { - createImport(path, module); - } - - path.remove(); - }; - }, - post() { - if (debug) { - logEntryPolyfills( - "@babel/polyfill", - this.importPolyfillIncluded, - polyfills, - this.file.opts.filename, - polyfillTargets, - corejs2Polyfills, - ); - } - }, - }; -} diff --git a/packages/babel-preset-env/src/polyfills/corejs2/get-platform-specific-default.js b/packages/babel-preset-env/src/polyfills/corejs2/get-platform-specific-default.js deleted file mode 100644 index 10674d433ccc..000000000000 --- a/packages/babel-preset-env/src/polyfills/corejs2/get-platform-specific-default.js +++ /dev/null @@ -1,17 +0,0 @@ -// @flow - -import type { Targets } from "@babel/helper-compilation-targets"; - -export const defaultWebIncludes = [ - "web.timers", - "web.immediate", - "web.dom.iterable", -]; - -export default function (targets: Targets): null | string[] { - const targetNames = Object.keys(targets); - const isAnyTarget = !targetNames.length; - const isWebTarget = targetNames.some(name => name !== "node"); - - return isAnyTarget || isWebTarget ? defaultWebIncludes : null; -} diff --git a/packages/babel-preset-env/src/polyfills/corejs2/usage-plugin.js b/packages/babel-preset-env/src/polyfills/corejs2/usage-plugin.js deleted file mode 100644 index 697be14c6050..000000000000 --- a/packages/babel-preset-env/src/polyfills/corejs2/usage-plugin.js +++ /dev/null @@ -1,222 +0,0 @@ -// @flow - -import corejs2Polyfills from "@babel/compat-data/corejs2-built-ins"; -import { filterItems } from "@babel/helper-compilation-targets"; -import getPlatformSpecificDefaultFor from "./get-platform-specific-default"; -import { - BuiltIns, - StaticProperties, - InstanceProperties, -} from "./built-in-definitions"; -import { - createImport, - getType, - has, - isPolyfillSource, - getImportSource, - getRequireSource, - isNamespaced, -} from "../../utils"; -import { logUsagePolyfills } from "../../debug"; - -import type { InternalPluginOptions } from "../../types"; -import type { NodePath } from "@babel/traverse"; - -const NO_DIRECT_POLYFILL_IMPORT = ` - When setting \`useBuiltIns: 'usage'\`, polyfills are automatically imported when needed. - Please remove the \`import '@babel/polyfill'\` call or use \`useBuiltIns: 'entry'\` instead.`; - -export default function ( - { types: t }: { types: Object }, - { include, exclude, polyfillTargets, debug }: InternalPluginOptions, -) { - const polyfills = filterItems( - corejs2Polyfills, - include, - exclude, - polyfillTargets, - getPlatformSpecificDefaultFor(polyfillTargets), - ); - - const addAndRemovePolyfillImports = { - ImportDeclaration(path: NodePath) { - if (isPolyfillSource(getImportSource(path))) { - console.warn(NO_DIRECT_POLYFILL_IMPORT); - path.remove(); - } - }, - - Program(path: NodePath) { - path.get("body").forEach(bodyPath => { - if (isPolyfillSource(getRequireSource(bodyPath))) { - console.warn(NO_DIRECT_POLYFILL_IMPORT); - bodyPath.remove(); - } - }); - }, - - // Symbol() - // new Promise - ReferencedIdentifier({ node: { name }, parent, scope }: NodePath) { - if (t.isMemberExpression(parent)) return; - if (!has(BuiltIns, name)) return; - if (scope.getBindingIdentifier(name)) return; - - const BuiltInDependencies = BuiltIns[name]; - this.addUnsupported(BuiltInDependencies); - }, - - // arr[Symbol.iterator]() - CallExpression(path: NodePath) { - // we can't compile this - if (path.node.arguments.length) return; - - const callee = path.node.callee; - - if (!t.isMemberExpression(callee)) return; - if (!callee.computed) return; - if (!path.get("callee.property").matchesPattern("Symbol.iterator")) { - return; - } - - this.addImport("web.dom.iterable"); - }, - - // Symbol.iterator in arr - BinaryExpression(path: NodePath) { - if (path.node.operator !== "in") return; - if (!path.get("left").matchesPattern("Symbol.iterator")) return; - - this.addImport("web.dom.iterable"); - }, - - // yield* - YieldExpression(path: NodePath) { - if (path.node.delegate) { - this.addImport("web.dom.iterable"); - } - }, - - // Array.from - MemberExpression: { - enter(path: NodePath) { - const { node } = path; - const { object, property } = node; - - // ignore namespace - if (isNamespaced(path.get("object"))) return; - - let evaluatedPropType = object.name; - let propertyName = ""; - let instanceType = ""; - - if (node.computed) { - if (t.isStringLiteral(property)) { - propertyName = property.value; - } else { - const result = path.get("property").evaluate(); - if (result.confident && result.value) { - propertyName = result.value; - } - } - } else { - propertyName = property.name; - } - - if (path.scope.getBindingIdentifier(object.name)) { - const result = path.get("object").evaluate(); - if (result.value) { - instanceType = getType(result.value); - } else if (result.deopt && result.deopt.isIdentifier()) { - evaluatedPropType = result.deopt.node.name; - } - } - - if (has(StaticProperties, evaluatedPropType)) { - const BuiltInProperties = StaticProperties[evaluatedPropType]; - if (has(BuiltInProperties, propertyName)) { - const StaticPropertyDependencies = BuiltInProperties[propertyName]; - this.addUnsupported(StaticPropertyDependencies); - } - } - - if (has(InstanceProperties, propertyName)) { - let InstancePropertyDependencies = InstanceProperties[propertyName]; - if (instanceType) { - InstancePropertyDependencies = InstancePropertyDependencies.filter( - module => module.includes(instanceType), - ); - } - this.addUnsupported(InstancePropertyDependencies); - } - }, - - // Symbol.match - exit(path: NodePath) { - const { name } = path.node.object; - - if (!has(BuiltIns, name)) return; - if (path.scope.getBindingIdentifier(name)) return; - - const BuiltInDependencies = BuiltIns[name]; - this.addUnsupported(BuiltInDependencies); - }, - }, - - // var { repeat, startsWith } = String - VariableDeclarator(path: NodePath) { - const { node } = path; - const { id, init } = node; - - if (!t.isObjectPattern(id)) return; - - // doesn't reference the global - if (init && path.scope.getBindingIdentifier(init.name)) return; - - for (const { key } of id.properties) { - if ( - !node.computed && - t.isIdentifier(key) && - has(InstanceProperties, key.name) - ) { - const InstancePropertyDependencies = InstanceProperties[key.name]; - this.addUnsupported(InstancePropertyDependencies); - } - } - }, - }; - - return { - name: "corejs2-usage", - pre({ path }: { path: NodePath }) { - this.polyfillsSet = new Set(); - - this.addImport = function (builtIn) { - if (!this.polyfillsSet.has(builtIn)) { - this.polyfillsSet.add(builtIn); - createImport(path, builtIn); - } - }; - - this.addUnsupported = function (builtIn) { - const modules = Array.isArray(builtIn) ? builtIn : [builtIn]; - for (const module of modules) { - if (polyfills.has(module)) { - this.addImport(module); - } - } - }; - }, - post() { - if (debug) { - logUsagePolyfills( - this.polyfillsSet, - this.file.opts.filename, - polyfillTargets, - corejs2Polyfills, - ); - } - }, - visitor: addAndRemovePolyfillImports, - }; -} diff --git a/packages/babel-preset-env/src/types.js b/packages/babel-preset-env/src/types.js index 780344b55550..24892ccfe98c 100644 --- a/packages/babel-preset-env/src/types.js +++ b/packages/babel-preset-env/src/types.js @@ -9,7 +9,7 @@ import type { Targets, InputTargets } from "@babel/helper-compilation-targets"; export type ModuleOption = $Values; export type BuiltInsOption = $Values; -type CorejsVersion = 2 | 3 | string; +type CorejsVersion = 3 | string; export type CorejsOption = | false diff --git a/packages/babel-preset-env/test/fixtures/corejs2/.entry-all-exec/exec.js b/packages/babel-preset-env/test/fixtures/corejs2/.entry-all-exec/exec.js deleted file mode 100644 index 38d3f9ccb9bc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/.entry-all-exec/exec.js +++ /dev/null @@ -1,3 +0,0 @@ -if (parseInt(process.version.slice(1)) > 5) { - require('@babel/polyfill'); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/.entry-all-exec/options.json b/packages/babel-preset-env/test/fixtures/corejs2/.entry-all-exec/options.json deleted file mode 100644 index ebc91c6d0fa8..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/.entry-all-exec/options.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage" - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-all/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-all/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-all/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-all/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-all/options.json deleted file mode 100644 index e5716ed34f4b..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-all/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-all/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-all/output.mjs deleted file mode 100644 index 50550d4322d8..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-all/output.mjs +++ /dev/null @@ -1,149 +0,0 @@ -import "core-js/modules/es6.array.copy-within"; -import "core-js/modules/es6.array.every"; -import "core-js/modules/es6.array.fill"; -import "core-js/modules/es6.array.filter"; -import "core-js/modules/es6.array.find"; -import "core-js/modules/es6.array.find-index"; -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.for-each"; -import "core-js/modules/es6.array.from"; -import "core-js/modules/es7.array.includes"; -import "core-js/modules/es6.array.index-of"; -import "core-js/modules/es6.array.is-array"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.array.last-index-of"; -import "core-js/modules/es6.array.map"; -import "core-js/modules/es6.array.of"; -import "core-js/modules/es6.array.reduce"; -import "core-js/modules/es6.array.reduce-right"; -import "core-js/modules/es6.array.some"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es6.array.species"; -import "core-js/modules/es6.date.now"; -import "core-js/modules/es6.date.to-iso-string"; -import "core-js/modules/es6.date.to-json"; -import "core-js/modules/es6.date.to-primitive"; -import "core-js/modules/es6.date.to-string"; -import "core-js/modules/es6.function.bind"; -import "core-js/modules/es6.function.has-instance"; -import "core-js/modules/es6.function.name"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.math.acosh"; -import "core-js/modules/es6.math.asinh"; -import "core-js/modules/es6.math.atanh"; -import "core-js/modules/es6.math.cbrt"; -import "core-js/modules/es6.math.clz32"; -import "core-js/modules/es6.math.cosh"; -import "core-js/modules/es6.math.expm1"; -import "core-js/modules/es6.math.fround"; -import "core-js/modules/es6.math.hypot"; -import "core-js/modules/es6.math.imul"; -import "core-js/modules/es6.math.log1p"; -import "core-js/modules/es6.math.log10"; -import "core-js/modules/es6.math.log2"; -import "core-js/modules/es6.math.sign"; -import "core-js/modules/es6.math.sinh"; -import "core-js/modules/es6.math.tanh"; -import "core-js/modules/es6.math.trunc"; -import "core-js/modules/es6.number.constructor"; -import "core-js/modules/es6.number.epsilon"; -import "core-js/modules/es6.number.is-finite"; -import "core-js/modules/es6.number.is-integer"; -import "core-js/modules/es6.number.is-nan"; -import "core-js/modules/es6.number.is-safe-integer"; -import "core-js/modules/es6.number.max-safe-integer"; -import "core-js/modules/es6.number.min-safe-integer"; -import "core-js/modules/es6.number.parse-float"; -import "core-js/modules/es6.number.parse-int"; -import "core-js/modules/es6.object.assign"; -import "core-js/modules/es6.object.create"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es6.object.define-property"; -import "core-js/modules/es6.object.define-properties"; -import "core-js/modules/es7.object.entries"; -import "core-js/modules/es6.object.freeze"; -import "core-js/modules/es6.object.get-own-property-descriptor"; -import "core-js/modules/es7.object.get-own-property-descriptors"; -import "core-js/modules/es6.object.get-own-property-names"; -import "core-js/modules/es6.object.get-prototype-of"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.prevent-extensions"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es6.object.is"; -import "core-js/modules/es6.object.is-frozen"; -import "core-js/modules/es6.object.is-sealed"; -import "core-js/modules/es6.object.is-extensible"; -import "core-js/modules/es6.object.keys"; -import "core-js/modules/es6.object.seal"; -import "core-js/modules/es6.object.set-prototype-of"; -import "core-js/modules/es7.object.values"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.reflect.apply"; -import "core-js/modules/es6.reflect.construct"; -import "core-js/modules/es6.reflect.define-property"; -import "core-js/modules/es6.reflect.delete-property"; -import "core-js/modules/es6.reflect.get"; -import "core-js/modules/es6.reflect.get-own-property-descriptor"; -import "core-js/modules/es6.reflect.get-prototype-of"; -import "core-js/modules/es6.reflect.has"; -import "core-js/modules/es6.reflect.is-extensible"; -import "core-js/modules/es6.reflect.own-keys"; -import "core-js/modules/es6.reflect.prevent-extensions"; -import "core-js/modules/es6.reflect.set"; -import "core-js/modules/es6.reflect.set-prototype-of"; -import "core-js/modules/es6.regexp.constructor"; -import "core-js/modules/es6.regexp.flags"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.regexp.to-string"; -import "core-js/modules/es6.set"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.string.anchor"; -import "core-js/modules/es6.string.big"; -import "core-js/modules/es6.string.blink"; -import "core-js/modules/es6.string.bold"; -import "core-js/modules/es6.string.code-point-at"; -import "core-js/modules/es6.string.ends-with"; -import "core-js/modules/es6.string.fixed"; -import "core-js/modules/es6.string.fontcolor"; -import "core-js/modules/es6.string.fontsize"; -import "core-js/modules/es6.string.from-code-point"; -import "core-js/modules/es6.string.includes"; -import "core-js/modules/es6.string.italics"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.string.link"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es6.string.raw"; -import "core-js/modules/es6.string.repeat"; -import "core-js/modules/es6.string.small"; -import "core-js/modules/es6.string.starts-with"; -import "core-js/modules/es6.string.strike"; -import "core-js/modules/es6.string.sub"; -import "core-js/modules/es6.string.sup"; -import "core-js/modules/es6.string.trim"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/es6.typed.array-buffer"; -import "core-js/modules/es6.typed.data-view"; -import "core-js/modules/es6.typed.int8-array"; -import "core-js/modules/es6.typed.uint8-array"; -import "core-js/modules/es6.typed.uint8-clamped-array"; -import "core-js/modules/es6.typed.int16-array"; -import "core-js/modules/es6.typed.uint16-array"; -import "core-js/modules/es6.typed.int32-array"; -import "core-js/modules/es6.typed.uint32-array"; -import "core-js/modules/es6.typed.float32-array"; -import "core-js/modules/es6.typed.float64-array"; -import "core-js/modules/es6.weak-map"; -import "core-js/modules/es6.weak-set"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/input.mjs deleted file mode 100644 index 9aaeea95a40c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "@babel/polyfill"; -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/options.json deleted file mode 100644 index e6be8cd4b1fd..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 48 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/output.mjs deleted file mode 100644 index 7f3479ae14b9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-48/output.mjs +++ /dev/null @@ -1,61 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.from"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es6.array.species"; -import "core-js/modules/es6.function.has-instance"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.object.assign"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.entries"; -import "core-js/modules/es7.object.get-own-property-descriptors"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.object.values"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.reflect.apply"; -import "core-js/modules/es6.reflect.construct"; -import "core-js/modules/es6.reflect.define-property"; -import "core-js/modules/es6.reflect.delete-property"; -import "core-js/modules/es6.reflect.get"; -import "core-js/modules/es6.reflect.get-own-property-descriptor"; -import "core-js/modules/es6.reflect.get-prototype-of"; -import "core-js/modules/es6.reflect.has"; -import "core-js/modules/es6.reflect.is-extensible"; -import "core-js/modules/es6.reflect.own-keys"; -import "core-js/modules/es6.reflect.prevent-extensions"; -import "core-js/modules/es6.reflect.set"; -import "core-js/modules/es6.reflect.set-prototype-of"; -import "core-js/modules/es6.regexp.constructor"; -import "core-js/modules/es6.regexp.flags"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.regexp.to-string"; -import "core-js/modules/es6.set"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/es6.typed.array-buffer"; -import "core-js/modules/es6.typed.int8-array"; -import "core-js/modules/es6.typed.uint8-array"; -import "core-js/modules/es6.typed.uint8-clamped-array"; -import "core-js/modules/es6.typed.int16-array"; -import "core-js/modules/es6.typed.uint16-array"; -import "core-js/modules/es6.typed.int32-array"; -import "core-js/modules/es6.typed.uint32-array"; -import "core-js/modules/es6.typed.float32-array"; -import "core-js/modules/es6.typed.float64-array"; -import "core-js/modules/es6.weak-map"; -import "core-js/modules/es6.weak-set"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; -Math.pow(1, 2); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/input.mjs deleted file mode 100644 index 9aaeea95a40c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "@babel/polyfill"; -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/options.json deleted file mode 100644 index 29a64d797cf7..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 49 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/output.mjs deleted file mode 100644 index d424cb017c55..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-49/output.mjs +++ /dev/null @@ -1,46 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.from"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es6.array.species"; -import "core-js/modules/es6.function.has-instance"; -import "core-js/modules/es6.map"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.entries"; -import "core-js/modules/es7.object.get-own-property-descriptors"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.object.values"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.regexp.constructor"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.regexp.to-string"; -import "core-js/modules/es6.set"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/es6.typed.array-buffer"; -import "core-js/modules/es6.typed.int8-array"; -import "core-js/modules/es6.typed.uint8-array"; -import "core-js/modules/es6.typed.uint8-clamped-array"; -import "core-js/modules/es6.typed.int16-array"; -import "core-js/modules/es6.typed.uint16-array"; -import "core-js/modules/es6.typed.int32-array"; -import "core-js/modules/es6.typed.uint32-array"; -import "core-js/modules/es6.typed.float32-array"; -import "core-js/modules/es6.typed.float64-array"; -import "core-js/modules/es6.weak-map"; -import "core-js/modules/es6.weak-set"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; -Math.pow(1, 2); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/input.mjs deleted file mode 100644 index b475c7ae52a0..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/input.mjs +++ /dev/null @@ -1,16 +0,0 @@ -import "@babel/polyfill"; - -const foo = { - a: true, -}; - -const bar = { - ...foo, - b: false, -}; - -async function baz() { - for await (const x of someAsyncThing()) { - console.log(x); - } -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/options.json deleted file mode 100644 index 5a0151ae5bf2..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": "66" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/output.mjs deleted file mode 100644 index ce33befd1127..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-66/output.mjs +++ /dev/null @@ -1,16 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -const foo = { - a: true -}; -const bar = { ...foo, - b: false -}; - -async function baz() { - for await (const x of someAsyncThing()) { - console.log(x); - } -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/input.mjs deleted file mode 100644 index b475c7ae52a0..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/input.mjs +++ /dev/null @@ -1,16 +0,0 @@ -import "@babel/polyfill"; - -const foo = { - a: true, -}; - -const bar = { - ...foo, - b: false, -}; - -async function baz() { - for await (const x of someAsyncThing()) { - console.log(x); - } -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/options.json deleted file mode 100644 index 344aa0ae6506..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": "71" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/output.mjs deleted file mode 100644 index aaa9444a59bd..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chrome-71/output.mjs +++ /dev/null @@ -1,15 +0,0 @@ -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -const foo = { - a: true -}; -const bar = { ...foo, - b: false -}; - -async function baz() { - for await (const x of someAsyncThing()) { - console.log(x); - } -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/input.mjs deleted file mode 100644 index 9aaeea95a40c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "@babel/polyfill"; -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/options.json deleted file mode 100644 index 167d33395b5b..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "browsers": "chromeandroid 59" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/output.mjs deleted file mode 100644 index 50912e84ee5f..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-chromeandroid/output.mjs +++ /dev/null @@ -1,14 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/input.mjs deleted file mode 100644 index 640bc11864fc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/input.mjs +++ /dev/null @@ -1 +0,0 @@ -require("core-js"); \ No newline at end of file diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/options.json deleted file mode 100644 index 19b78ca4577d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 55 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/output.mjs deleted file mode 100644 index 0d844da81283..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main-require/output.mjs +++ /dev/null @@ -1,16 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/input.mjs deleted file mode 100644 index bd6332b8bac3..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "core-js"; \ No newline at end of file diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/options.json deleted file mode 100644 index 19b78ca4577d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 55 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/output.mjs deleted file mode 100644 index 0d844da81283..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-core-js-main/output.mjs +++ /dev/null @@ -1,16 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/input.mjs deleted file mode 100644 index 15476514534b..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -import "@babel/polyfill"; - -a ** b; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/options.json deleted file mode 100644 index fe07d418a7f9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "electron": "1.4" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/output.mjs deleted file mode 100644 index 6acf992d40b8..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-electron/output.mjs +++ /dev/null @@ -1,17 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -a ** b; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/options.json deleted file mode 100644 index 280e9827e693..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "ie": 11 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/output.mjs deleted file mode 100644 index 220ad965edab..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-11/output.mjs +++ /dev/null @@ -1,127 +0,0 @@ -import "core-js/modules/es6.array.copy-within"; -import "core-js/modules/es6.array.fill"; -import "core-js/modules/es6.array.find"; -import "core-js/modules/es6.array.find-index"; -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.from"; -import "core-js/modules/es7.array.includes"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.array.of"; -import "core-js/modules/es6.array.species"; -import "core-js/modules/es6.date.to-primitive"; -import "core-js/modules/es6.function.has-instance"; -import "core-js/modules/es6.function.name"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.math.acosh"; -import "core-js/modules/es6.math.asinh"; -import "core-js/modules/es6.math.atanh"; -import "core-js/modules/es6.math.cbrt"; -import "core-js/modules/es6.math.clz32"; -import "core-js/modules/es6.math.cosh"; -import "core-js/modules/es6.math.expm1"; -import "core-js/modules/es6.math.fround"; -import "core-js/modules/es6.math.hypot"; -import "core-js/modules/es6.math.imul"; -import "core-js/modules/es6.math.log1p"; -import "core-js/modules/es6.math.log10"; -import "core-js/modules/es6.math.log2"; -import "core-js/modules/es6.math.sign"; -import "core-js/modules/es6.math.sinh"; -import "core-js/modules/es6.math.tanh"; -import "core-js/modules/es6.math.trunc"; -import "core-js/modules/es6.number.constructor"; -import "core-js/modules/es6.number.epsilon"; -import "core-js/modules/es6.number.is-finite"; -import "core-js/modules/es6.number.is-integer"; -import "core-js/modules/es6.number.is-nan"; -import "core-js/modules/es6.number.is-safe-integer"; -import "core-js/modules/es6.number.max-safe-integer"; -import "core-js/modules/es6.number.min-safe-integer"; -import "core-js/modules/es6.number.parse-float"; -import "core-js/modules/es6.number.parse-int"; -import "core-js/modules/es6.object.assign"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.entries"; -import "core-js/modules/es6.object.freeze"; -import "core-js/modules/es6.object.get-own-property-descriptor"; -import "core-js/modules/es7.object.get-own-property-descriptors"; -import "core-js/modules/es6.object.get-own-property-names"; -import "core-js/modules/es6.object.get-prototype-of"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.prevent-extensions"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es6.object.is"; -import "core-js/modules/es6.object.is-frozen"; -import "core-js/modules/es6.object.is-sealed"; -import "core-js/modules/es6.object.is-extensible"; -import "core-js/modules/es6.object.keys"; -import "core-js/modules/es6.object.seal"; -import "core-js/modules/es7.object.values"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.reflect.apply"; -import "core-js/modules/es6.reflect.construct"; -import "core-js/modules/es6.reflect.define-property"; -import "core-js/modules/es6.reflect.delete-property"; -import "core-js/modules/es6.reflect.get"; -import "core-js/modules/es6.reflect.get-own-property-descriptor"; -import "core-js/modules/es6.reflect.get-prototype-of"; -import "core-js/modules/es6.reflect.has"; -import "core-js/modules/es6.reflect.is-extensible"; -import "core-js/modules/es6.reflect.own-keys"; -import "core-js/modules/es6.reflect.prevent-extensions"; -import "core-js/modules/es6.reflect.set"; -import "core-js/modules/es6.reflect.set-prototype-of"; -import "core-js/modules/es6.regexp.constructor"; -import "core-js/modules/es6.regexp.flags"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.regexp.to-string"; -import "core-js/modules/es6.set"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.string.anchor"; -import "core-js/modules/es6.string.big"; -import "core-js/modules/es6.string.blink"; -import "core-js/modules/es6.string.bold"; -import "core-js/modules/es6.string.code-point-at"; -import "core-js/modules/es6.string.ends-with"; -import "core-js/modules/es6.string.fixed"; -import "core-js/modules/es6.string.fontcolor"; -import "core-js/modules/es6.string.fontsize"; -import "core-js/modules/es6.string.from-code-point"; -import "core-js/modules/es6.string.includes"; -import "core-js/modules/es6.string.italics"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.string.link"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es6.string.raw"; -import "core-js/modules/es6.string.repeat"; -import "core-js/modules/es6.string.small"; -import "core-js/modules/es6.string.starts-with"; -import "core-js/modules/es6.string.strike"; -import "core-js/modules/es6.string.sub"; -import "core-js/modules/es6.string.sup"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/es6.typed.array-buffer"; -import "core-js/modules/es6.typed.int8-array"; -import "core-js/modules/es6.typed.uint8-array"; -import "core-js/modules/es6.typed.uint8-clamped-array"; -import "core-js/modules/es6.typed.int16-array"; -import "core-js/modules/es6.typed.uint16-array"; -import "core-js/modules/es6.typed.int32-array"; -import "core-js/modules/es6.typed.uint32-array"; -import "core-js/modules/es6.typed.float32-array"; -import "core-js/modules/es6.typed.float64-array"; -import "core-js/modules/es6.weak-map"; -import "core-js/modules/es6.weak-set"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/options.json deleted file mode 100644 index a955fd914bb2..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "ie": 9 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/output.mjs deleted file mode 100644 index 9012ed720c20..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-ie-9/output.mjs +++ /dev/null @@ -1,130 +0,0 @@ -import "core-js/modules/es6.array.copy-within"; -import "core-js/modules/es6.array.fill"; -import "core-js/modules/es6.array.find"; -import "core-js/modules/es6.array.find-index"; -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.from"; -import "core-js/modules/es7.array.includes"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.array.of"; -import "core-js/modules/es6.array.species"; -import "core-js/modules/es6.date.to-primitive"; -import "core-js/modules/es6.date.to-string"; -import "core-js/modules/es6.function.has-instance"; -import "core-js/modules/es6.function.name"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.math.acosh"; -import "core-js/modules/es6.math.asinh"; -import "core-js/modules/es6.math.atanh"; -import "core-js/modules/es6.math.cbrt"; -import "core-js/modules/es6.math.clz32"; -import "core-js/modules/es6.math.cosh"; -import "core-js/modules/es6.math.expm1"; -import "core-js/modules/es6.math.fround"; -import "core-js/modules/es6.math.hypot"; -import "core-js/modules/es6.math.imul"; -import "core-js/modules/es6.math.log1p"; -import "core-js/modules/es6.math.log10"; -import "core-js/modules/es6.math.log2"; -import "core-js/modules/es6.math.sign"; -import "core-js/modules/es6.math.sinh"; -import "core-js/modules/es6.math.tanh"; -import "core-js/modules/es6.math.trunc"; -import "core-js/modules/es6.number.constructor"; -import "core-js/modules/es6.number.epsilon"; -import "core-js/modules/es6.number.is-finite"; -import "core-js/modules/es6.number.is-integer"; -import "core-js/modules/es6.number.is-nan"; -import "core-js/modules/es6.number.is-safe-integer"; -import "core-js/modules/es6.number.max-safe-integer"; -import "core-js/modules/es6.number.min-safe-integer"; -import "core-js/modules/es6.number.parse-float"; -import "core-js/modules/es6.number.parse-int"; -import "core-js/modules/es6.object.assign"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.entries"; -import "core-js/modules/es6.object.freeze"; -import "core-js/modules/es6.object.get-own-property-descriptor"; -import "core-js/modules/es7.object.get-own-property-descriptors"; -import "core-js/modules/es6.object.get-own-property-names"; -import "core-js/modules/es6.object.get-prototype-of"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.prevent-extensions"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es6.object.is"; -import "core-js/modules/es6.object.is-frozen"; -import "core-js/modules/es6.object.is-sealed"; -import "core-js/modules/es6.object.is-extensible"; -import "core-js/modules/es6.object.keys"; -import "core-js/modules/es6.object.seal"; -import "core-js/modules/es6.object.set-prototype-of"; -import "core-js/modules/es7.object.values"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.reflect.apply"; -import "core-js/modules/es6.reflect.construct"; -import "core-js/modules/es6.reflect.define-property"; -import "core-js/modules/es6.reflect.delete-property"; -import "core-js/modules/es6.reflect.get"; -import "core-js/modules/es6.reflect.get-own-property-descriptor"; -import "core-js/modules/es6.reflect.get-prototype-of"; -import "core-js/modules/es6.reflect.has"; -import "core-js/modules/es6.reflect.is-extensible"; -import "core-js/modules/es6.reflect.own-keys"; -import "core-js/modules/es6.reflect.prevent-extensions"; -import "core-js/modules/es6.reflect.set"; -import "core-js/modules/es6.reflect.set-prototype-of"; -import "core-js/modules/es6.regexp.constructor"; -import "core-js/modules/es6.regexp.flags"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.regexp.to-string"; -import "core-js/modules/es6.set"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.string.anchor"; -import "core-js/modules/es6.string.big"; -import "core-js/modules/es6.string.blink"; -import "core-js/modules/es6.string.bold"; -import "core-js/modules/es6.string.code-point-at"; -import "core-js/modules/es6.string.ends-with"; -import "core-js/modules/es6.string.fixed"; -import "core-js/modules/es6.string.fontcolor"; -import "core-js/modules/es6.string.fontsize"; -import "core-js/modules/es6.string.from-code-point"; -import "core-js/modules/es6.string.includes"; -import "core-js/modules/es6.string.italics"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.string.link"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es6.string.raw"; -import "core-js/modules/es6.string.repeat"; -import "core-js/modules/es6.string.small"; -import "core-js/modules/es6.string.starts-with"; -import "core-js/modules/es6.string.strike"; -import "core-js/modules/es6.string.sub"; -import "core-js/modules/es6.string.sup"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/es6.typed.array-buffer"; -import "core-js/modules/es6.typed.data-view"; -import "core-js/modules/es6.typed.int8-array"; -import "core-js/modules/es6.typed.uint8-array"; -import "core-js/modules/es6.typed.uint8-clamped-array"; -import "core-js/modules/es6.typed.int16-array"; -import "core-js/modules/es6.typed.uint16-array"; -import "core-js/modules/es6.typed.int32-array"; -import "core-js/modules/es6.typed.uint32-array"; -import "core-js/modules/es6.typed.float32-array"; -import "core-js/modules/es6.typed.float64-array"; -import "core-js/modules/es6.weak-map"; -import "core-js/modules/es6.weak-set"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-import/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-import/input.mjs deleted file mode 100644 index 9aaeea95a40c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-import/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "@babel/polyfill"; -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-import/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-import/options.json deleted file mode 100644 index 19b78ca4577d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-import/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 55 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-import/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-import/output.mjs deleted file mode 100644 index 68e37cc3ea2e..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-import/output.mjs +++ /dev/null @@ -1,17 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/input.mjs deleted file mode 100644 index cce2c112e09f..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "@babel/polyfill"; - diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/options.json deleted file mode 100644 index 0bc0d53b8459..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "node": "10.13" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/output.mjs deleted file mode 100644 index 0518d02b9cc2..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-10.13/output.mjs +++ /dev/null @@ -1 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/input.mjs deleted file mode 100644 index cce2c112e09f..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "@babel/polyfill"; - diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/options.json deleted file mode 100644 index c8b34662cfef..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "node": "11" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/output.mjs deleted file mode 100644 index 8b137891791f..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-11/output.mjs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/options.json deleted file mode 100644 index 56fd28fa3d68..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": "55", - "node": "7.6" - }, - "modules": false, - "useBuiltIns": "entry", - "forceAllTransforms": true, - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/output.mjs deleted file mode 100644 index a9f27a4dced7..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node-web/output.mjs +++ /dev/null @@ -1,17 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-node/options.json deleted file mode 100644 index fc9b166ab908..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node/options.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "node": "7.6" - }, - "modules": false, - "useBuiltIns": "entry", - "forceAllTransforms": true, - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-node/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/entry-node/output.mjs deleted file mode 100644 index 2afa855ac7eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-node/output.mjs +++ /dev/null @@ -1,14 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "regenerator-runtime/runtime"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-require/input.js b/packages/babel-preset-env/test/fixtures/corejs2/entry-require/input.js deleted file mode 100644 index 6bbea2630d2d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-require/input.js +++ /dev/null @@ -1,3 +0,0 @@ -require("@babel/polyfill"); - -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-require/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-require/options.json deleted file mode 100644 index b1dae07978c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-require/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": "55" - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-require/output.js b/packages/babel-preset-env/test/fixtures/corejs2/entry-require/output.js deleted file mode 100644 index 70393b8eae04..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-require/output.js +++ /dev/null @@ -1,33 +0,0 @@ -require("core-js/modules/es7.array.flat-map"); - -require("core-js/modules/es6.array.sort"); - -require("core-js/modules/es7.object.define-getter"); - -require("core-js/modules/es7.object.define-setter"); - -require("core-js/modules/es7.object.lookup-getter"); - -require("core-js/modules/es7.object.lookup-setter"); - -require("core-js/modules/es6.object.to-string"); - -require("core-js/modules/es7.promise.finally"); - -require("core-js/modules/es7.symbol.async-iterator"); - -require("core-js/modules/es7.string.pad-start"); - -require("core-js/modules/es7.string.pad-end"); - -require("core-js/modules/es7.string.trim-left"); - -require("core-js/modules/es7.string.trim-right"); - -require("core-js/modules/web.timers"); - -require("core-js/modules/web.immediate"); - -require("core-js/modules/web.dom.iterable"); - -1 ** 2; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/input.js b/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/input.js deleted file mode 100644 index 139b7c19f808..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/input.js +++ /dev/null @@ -1,8 +0,0 @@ -require("@babel/polyfill"); - -let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 }; -let n = { x, y, ...z }; -async function* agf() { - await 1; - yield 2; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/options.json b/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/options.json deleted file mode 100644 index 10e3737d2b65..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "shippedProposals": true, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/output.js b/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/output.js deleted file mode 100644 index c70b52bf9a03..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/entry-shippedProposals/output.js +++ /dev/null @@ -1,365 +0,0 @@ -require("core-js/modules/es6.array.copy-within"); - -require("core-js/modules/es6.array.every"); - -require("core-js/modules/es6.array.fill"); - -require("core-js/modules/es6.array.filter"); - -require("core-js/modules/es6.array.find"); - -require("core-js/modules/es6.array.find-index"); - -require("core-js/modules/es7.array.flat-map"); - -require("core-js/modules/es6.array.for-each"); - -require("core-js/modules/es6.array.from"); - -require("core-js/modules/es7.array.includes"); - -require("core-js/modules/es6.array.index-of"); - -require("core-js/modules/es6.array.is-array"); - -require("core-js/modules/es6.array.iterator"); - -require("core-js/modules/es6.array.last-index-of"); - -require("core-js/modules/es6.array.map"); - -require("core-js/modules/es6.array.of"); - -require("core-js/modules/es6.array.reduce"); - -require("core-js/modules/es6.array.reduce-right"); - -require("core-js/modules/es6.array.some"); - -require("core-js/modules/es6.array.sort"); - -require("core-js/modules/es6.array.species"); - -require("core-js/modules/es6.date.now"); - -require("core-js/modules/es6.date.to-iso-string"); - -require("core-js/modules/es6.date.to-json"); - -require("core-js/modules/es6.date.to-primitive"); - -require("core-js/modules/es6.date.to-string"); - -require("core-js/modules/es6.function.bind"); - -require("core-js/modules/es6.function.has-instance"); - -require("core-js/modules/es6.function.name"); - -require("core-js/modules/es6.map"); - -require("core-js/modules/es6.math.acosh"); - -require("core-js/modules/es6.math.asinh"); - -require("core-js/modules/es6.math.atanh"); - -require("core-js/modules/es6.math.cbrt"); - -require("core-js/modules/es6.math.clz32"); - -require("core-js/modules/es6.math.cosh"); - -require("core-js/modules/es6.math.expm1"); - -require("core-js/modules/es6.math.fround"); - -require("core-js/modules/es6.math.hypot"); - -require("core-js/modules/es6.math.imul"); - -require("core-js/modules/es6.math.log1p"); - -require("core-js/modules/es6.math.log10"); - -require("core-js/modules/es6.math.log2"); - -require("core-js/modules/es6.math.sign"); - -require("core-js/modules/es6.math.sinh"); - -require("core-js/modules/es6.math.tanh"); - -require("core-js/modules/es6.math.trunc"); - -require("core-js/modules/es6.number.constructor"); - -require("core-js/modules/es6.number.epsilon"); - -require("core-js/modules/es6.number.is-finite"); - -require("core-js/modules/es6.number.is-integer"); - -require("core-js/modules/es6.number.is-nan"); - -require("core-js/modules/es6.number.is-safe-integer"); - -require("core-js/modules/es6.number.max-safe-integer"); - -require("core-js/modules/es6.number.min-safe-integer"); - -require("core-js/modules/es6.number.parse-float"); - -require("core-js/modules/es6.number.parse-int"); - -require("core-js/modules/es6.object.assign"); - -require("core-js/modules/es6.object.create"); - -require("core-js/modules/es7.object.define-getter"); - -require("core-js/modules/es7.object.define-setter"); - -require("core-js/modules/es6.object.define-property"); - -require("core-js/modules/es6.object.define-properties"); - -require("core-js/modules/es7.object.entries"); - -require("core-js/modules/es6.object.freeze"); - -require("core-js/modules/es6.object.get-own-property-descriptor"); - -require("core-js/modules/es7.object.get-own-property-descriptors"); - -require("core-js/modules/es6.object.get-own-property-names"); - -require("core-js/modules/es6.object.get-prototype-of"); - -require("core-js/modules/es7.object.lookup-getter"); - -require("core-js/modules/es7.object.lookup-setter"); - -require("core-js/modules/es6.object.prevent-extensions"); - -require("core-js/modules/es6.object.to-string"); - -require("core-js/modules/es6.object.is"); - -require("core-js/modules/es6.object.is-frozen"); - -require("core-js/modules/es6.object.is-sealed"); - -require("core-js/modules/es6.object.is-extensible"); - -require("core-js/modules/es6.object.keys"); - -require("core-js/modules/es6.object.seal"); - -require("core-js/modules/es6.object.set-prototype-of"); - -require("core-js/modules/es7.object.values"); - -require("core-js/modules/es6.promise"); - -require("core-js/modules/es7.promise.finally"); - -require("core-js/modules/es6.reflect.apply"); - -require("core-js/modules/es6.reflect.construct"); - -require("core-js/modules/es6.reflect.define-property"); - -require("core-js/modules/es6.reflect.delete-property"); - -require("core-js/modules/es6.reflect.get"); - -require("core-js/modules/es6.reflect.get-own-property-descriptor"); - -require("core-js/modules/es6.reflect.get-prototype-of"); - -require("core-js/modules/es6.reflect.has"); - -require("core-js/modules/es6.reflect.is-extensible"); - -require("core-js/modules/es6.reflect.own-keys"); - -require("core-js/modules/es6.reflect.prevent-extensions"); - -require("core-js/modules/es6.reflect.set"); - -require("core-js/modules/es6.reflect.set-prototype-of"); - -require("core-js/modules/es6.regexp.constructor"); - -require("core-js/modules/es6.regexp.flags"); - -require("core-js/modules/es6.regexp.match"); - -require("core-js/modules/es6.regexp.replace"); - -require("core-js/modules/es6.regexp.split"); - -require("core-js/modules/es6.regexp.search"); - -require("core-js/modules/es6.regexp.to-string"); - -require("core-js/modules/es6.set"); - -require("core-js/modules/es6.symbol"); - -require("core-js/modules/es7.symbol.async-iterator"); - -require("core-js/modules/es6.string.anchor"); - -require("core-js/modules/es6.string.big"); - -require("core-js/modules/es6.string.blink"); - -require("core-js/modules/es6.string.bold"); - -require("core-js/modules/es6.string.code-point-at"); - -require("core-js/modules/es6.string.ends-with"); - -require("core-js/modules/es6.string.fixed"); - -require("core-js/modules/es6.string.fontcolor"); - -require("core-js/modules/es6.string.fontsize"); - -require("core-js/modules/es6.string.from-code-point"); - -require("core-js/modules/es6.string.includes"); - -require("core-js/modules/es6.string.italics"); - -require("core-js/modules/es6.string.iterator"); - -require("core-js/modules/es6.string.link"); - -require("core-js/modules/es7.string.pad-start"); - -require("core-js/modules/es7.string.pad-end"); - -require("core-js/modules/es6.string.raw"); - -require("core-js/modules/es6.string.repeat"); - -require("core-js/modules/es6.string.small"); - -require("core-js/modules/es6.string.starts-with"); - -require("core-js/modules/es6.string.strike"); - -require("core-js/modules/es6.string.sub"); - -require("core-js/modules/es6.string.sup"); - -require("core-js/modules/es6.string.trim"); - -require("core-js/modules/es7.string.trim-left"); - -require("core-js/modules/es7.string.trim-right"); - -require("core-js/modules/es6.typed.array-buffer"); - -require("core-js/modules/es6.typed.data-view"); - -require("core-js/modules/es6.typed.int8-array"); - -require("core-js/modules/es6.typed.uint8-array"); - -require("core-js/modules/es6.typed.uint8-clamped-array"); - -require("core-js/modules/es6.typed.int16-array"); - -require("core-js/modules/es6.typed.uint16-array"); - -require("core-js/modules/es6.typed.int32-array"); - -require("core-js/modules/es6.typed.uint32-array"); - -require("core-js/modules/es6.typed.float32-array"); - -require("core-js/modules/es6.typed.float64-array"); - -require("core-js/modules/es6.weak-map"); - -require("core-js/modules/es6.weak-set"); - -require("core-js/modules/web.timers"); - -require("core-js/modules/web.immediate"); - -require("core-js/modules/web.dom.iterable"); - -require("regenerator-runtime/runtime"); - -function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } - -function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } - -function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } - -function _awaitAsyncGenerator(value) { return new _AwaitValue(value); } - -function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; } - -function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen["return"] !== "function") { this["return"] = undefined; } } - -if (typeof Symbol === "function" && Symbol.asyncIterator) { _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; }; } - -_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); }; - -_AsyncGenerator.prototype["throw"] = function (arg) { return this._invoke("throw", arg); }; - -_AsyncGenerator.prototype["return"] = function (arg) { return this._invoke("return", arg); }; - -function _AwaitValue(value) { this.wrapped = value; } - -var _x$y$a$b = { - x: 1, - y: 2, - a: 3, - b: 4 -}, - x = _x$y$a$b.x, - y = _x$y$a$b.y, - z = _objectWithoutProperties(_x$y$a$b, ["x", "y"]); - -var n = _objectSpread({ - x: x, - y: y -}, z); - -function agf() { - return _agf.apply(this, arguments); -} - -function _agf() { - _agf = _wrapAsyncGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { - return regeneratorRuntime.wrap(function _callee$(_context) { - while (1) { - switch (_context.prev = _context.next) { - case 0: - _context.next = 2; - return _awaitAsyncGenerator(1); - - case 2: - _context.next = 4; - return 2; - - case 4: - case "end": - return _context.stop(); - } - } - }, _callee); - })); - return _agf.apply(this, arguments); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/options.json b/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/options.json deleted file mode 100644 index f3f1b4733a05..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/options.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 63 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2, - "exclude": [ - "es7.array.flat-map", - "web.timers", - "web.immediate", - "web.dom.iterable" - ] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/output.mjs deleted file mode 100644 index 71b8fdb1d834..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-built-ins/output.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/input.mjs deleted file mode 100644 index 8be10283d852..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/input.mjs +++ /dev/null @@ -1,7 +0,0 @@ -import "@babel/polyfill"; - -async function a() { - await 1; -} - -(() => {}) diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/options.json b/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/options.json deleted file mode 100644 index 73ac20486207..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/options.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 55 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2, - "exclude": [ - "transform-async-to-generator", - "transform-regenerator", - "es6.string.repeat" - ], - "include": ["transform-arrow-functions", "es6.map"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/output.mjs deleted file mode 100644 index 265ac0ac0365..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-include/output.mjs +++ /dev/null @@ -1,23 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es6.map"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; - -async function a() { - await 1; -} - -(function () {}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/options.json b/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/options.json deleted file mode 100644 index 376e03903748..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "modules": false, - "useBuiltIns": "entry", - "corejs": 2, - "exclude": ["transform-regenerator"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/output.mjs deleted file mode 100644 index e8994bd76301..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude-regenerator/output.mjs +++ /dev/null @@ -1,148 +0,0 @@ -import "core-js/modules/es6.array.copy-within"; -import "core-js/modules/es6.array.every"; -import "core-js/modules/es6.array.fill"; -import "core-js/modules/es6.array.filter"; -import "core-js/modules/es6.array.find"; -import "core-js/modules/es6.array.find-index"; -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.for-each"; -import "core-js/modules/es6.array.from"; -import "core-js/modules/es7.array.includes"; -import "core-js/modules/es6.array.index-of"; -import "core-js/modules/es6.array.is-array"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.array.last-index-of"; -import "core-js/modules/es6.array.map"; -import "core-js/modules/es6.array.of"; -import "core-js/modules/es6.array.reduce"; -import "core-js/modules/es6.array.reduce-right"; -import "core-js/modules/es6.array.some"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es6.array.species"; -import "core-js/modules/es6.date.now"; -import "core-js/modules/es6.date.to-iso-string"; -import "core-js/modules/es6.date.to-json"; -import "core-js/modules/es6.date.to-primitive"; -import "core-js/modules/es6.date.to-string"; -import "core-js/modules/es6.function.bind"; -import "core-js/modules/es6.function.has-instance"; -import "core-js/modules/es6.function.name"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.math.acosh"; -import "core-js/modules/es6.math.asinh"; -import "core-js/modules/es6.math.atanh"; -import "core-js/modules/es6.math.cbrt"; -import "core-js/modules/es6.math.clz32"; -import "core-js/modules/es6.math.cosh"; -import "core-js/modules/es6.math.expm1"; -import "core-js/modules/es6.math.fround"; -import "core-js/modules/es6.math.hypot"; -import "core-js/modules/es6.math.imul"; -import "core-js/modules/es6.math.log1p"; -import "core-js/modules/es6.math.log10"; -import "core-js/modules/es6.math.log2"; -import "core-js/modules/es6.math.sign"; -import "core-js/modules/es6.math.sinh"; -import "core-js/modules/es6.math.tanh"; -import "core-js/modules/es6.math.trunc"; -import "core-js/modules/es6.number.constructor"; -import "core-js/modules/es6.number.epsilon"; -import "core-js/modules/es6.number.is-finite"; -import "core-js/modules/es6.number.is-integer"; -import "core-js/modules/es6.number.is-nan"; -import "core-js/modules/es6.number.is-safe-integer"; -import "core-js/modules/es6.number.max-safe-integer"; -import "core-js/modules/es6.number.min-safe-integer"; -import "core-js/modules/es6.number.parse-float"; -import "core-js/modules/es6.number.parse-int"; -import "core-js/modules/es6.object.assign"; -import "core-js/modules/es6.object.create"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es6.object.define-property"; -import "core-js/modules/es6.object.define-properties"; -import "core-js/modules/es7.object.entries"; -import "core-js/modules/es6.object.freeze"; -import "core-js/modules/es6.object.get-own-property-descriptor"; -import "core-js/modules/es7.object.get-own-property-descriptors"; -import "core-js/modules/es6.object.get-own-property-names"; -import "core-js/modules/es6.object.get-prototype-of"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.prevent-extensions"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es6.object.is"; -import "core-js/modules/es6.object.is-frozen"; -import "core-js/modules/es6.object.is-sealed"; -import "core-js/modules/es6.object.is-extensible"; -import "core-js/modules/es6.object.keys"; -import "core-js/modules/es6.object.seal"; -import "core-js/modules/es6.object.set-prototype-of"; -import "core-js/modules/es7.object.values"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.reflect.apply"; -import "core-js/modules/es6.reflect.construct"; -import "core-js/modules/es6.reflect.define-property"; -import "core-js/modules/es6.reflect.delete-property"; -import "core-js/modules/es6.reflect.get"; -import "core-js/modules/es6.reflect.get-own-property-descriptor"; -import "core-js/modules/es6.reflect.get-prototype-of"; -import "core-js/modules/es6.reflect.has"; -import "core-js/modules/es6.reflect.is-extensible"; -import "core-js/modules/es6.reflect.own-keys"; -import "core-js/modules/es6.reflect.prevent-extensions"; -import "core-js/modules/es6.reflect.set"; -import "core-js/modules/es6.reflect.set-prototype-of"; -import "core-js/modules/es6.regexp.constructor"; -import "core-js/modules/es6.regexp.flags"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.regexp.to-string"; -import "core-js/modules/es6.set"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.string.anchor"; -import "core-js/modules/es6.string.big"; -import "core-js/modules/es6.string.blink"; -import "core-js/modules/es6.string.bold"; -import "core-js/modules/es6.string.code-point-at"; -import "core-js/modules/es6.string.ends-with"; -import "core-js/modules/es6.string.fixed"; -import "core-js/modules/es6.string.fontcolor"; -import "core-js/modules/es6.string.fontsize"; -import "core-js/modules/es6.string.from-code-point"; -import "core-js/modules/es6.string.includes"; -import "core-js/modules/es6.string.italics"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.string.link"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es6.string.raw"; -import "core-js/modules/es6.string.repeat"; -import "core-js/modules/es6.string.small"; -import "core-js/modules/es6.string.starts-with"; -import "core-js/modules/es6.string.strike"; -import "core-js/modules/es6.string.sub"; -import "core-js/modules/es6.string.sup"; -import "core-js/modules/es6.string.trim"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/es6.typed.array-buffer"; -import "core-js/modules/es6.typed.data-view"; -import "core-js/modules/es6.typed.int8-array"; -import "core-js/modules/es6.typed.uint8-array"; -import "core-js/modules/es6.typed.uint8-clamped-array"; -import "core-js/modules/es6.typed.int16-array"; -import "core-js/modules/es6.typed.uint16-array"; -import "core-js/modules/es6.typed.int32-array"; -import "core-js/modules/es6.typed.uint32-array"; -import "core-js/modules/es6.typed.float32-array"; -import "core-js/modules/es6.typed.float64-array"; -import "core-js/modules/es6.weak-map"; -import "core-js/modules/es6.weak-set"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude/input.mjs deleted file mode 100644 index c70b44b5a432..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -async function a() { - await 1; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude/options.json b/packages/babel-preset-env/test/fixtures/corejs2/exclude/options.json deleted file mode 100644 index 0dd423720230..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "modules": false, - "useBuiltIns": "usage", - "corejs": 2, - "exclude": ["transform-async-to-generator", "transform-regenerator"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/exclude/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/exclude/output.mjs deleted file mode 100644 index c70b44b5a432..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/exclude/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -async function a() { - await 1; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/input.mjs deleted file mode 100644 index 76f3af0564c0..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -import "@babel/polyfill"; - -const a = 1; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/options.json b/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/options.json deleted file mode 100644 index a16df6bc3e50..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/options.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 55 - }, - "modules": false, - "useBuiltIns": "entry", - "corejs": 2, - "forceAllTransforms": true - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/output.mjs deleted file mode 100644 index 3cb3bf4ca5aa..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/force-all-transforms/output.mjs +++ /dev/null @@ -1,18 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; -import "regenerator-runtime/runtime"; -var a = 1; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/input.mjs deleted file mode 100644 index b4ece7b964c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "@babel/polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/options.json b/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/options.json deleted file mode 100644 index c6fc181232c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/options.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": 55 - }, - "include": ["es6.map", "es6.set"], - "modules": false, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/output.mjs deleted file mode 100644 index cdc603eea1d3..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/include-built-ins/output.mjs +++ /dev/null @@ -1,18 +0,0 @@ -import "core-js/modules/es7.array.flat-map"; -import "core-js/modules/es6.array.sort"; -import "core-js/modules/es6.map"; -import "core-js/modules/es7.object.define-getter"; -import "core-js/modules/es7.object.define-setter"; -import "core-js/modules/es7.object.lookup-getter"; -import "core-js/modules/es7.object.lookup-setter"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.set"; -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.trim-left"; -import "core-js/modules/es7.string.trim-right"; -import "core-js/modules/web.timers"; -import "core-js/modules/web.immediate"; -import "core-js/modules/web.dom.iterable"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-all/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-all/input.mjs deleted file mode 100644 index fff74225a250..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-all/input.mjs +++ /dev/null @@ -1,18 +0,0 @@ -Array.from; // static method -Map; // built-in -new Promise(); // new builtin -Symbol.match; // as member expression -_arr[Symbol.iterator](); // Symbol.iterator - -// no import -Array.asdf; -Array2.from; -Map2; -new Promise2(); -Symbol.asdf; -Symbol2.match; -_arr9[Symbol2.iterator](); -_arr9[Symbol.iterator2](); - -G.assign; // static method -function H(WeakMap) { var blah = new WeakMap(); } // shadowed diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-all/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-all/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-all/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-all/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-all/output.mjs deleted file mode 100644 index ccc11ee5c78d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-all/output.mjs +++ /dev/null @@ -1,38 +0,0 @@ -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/es6.regexp.match"; -import "core-js/modules/es6.promise"; -import "core-js/modules/web.dom.iterable"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.array.from"; -Array.from; // static method - -Map; // built-in - -new Promise(); // new builtin - -Symbol.match; // as member expression - -_arr[Symbol.iterator](); // Symbol.iterator -// no import - - -Array.asdf; -Array2.from; -Map2; -new Promise2(); -Symbol.asdf; -Symbol2.match; - -_arr9[Symbol2.iterator](); - -_arr9[Symbol.iterator2](); - -G.assign; // static method - -function H(WeakMap) { - var blah = new WeakMap(); -} // shadowed diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/browserslist b/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/browserslist deleted file mode 100644 index d0ae78fe6a24..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/browserslist +++ /dev/null @@ -1 +0,0 @@ -chrome 55 diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/input.mjs deleted file mode 100644 index f9e8d5a95638..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/input.mjs +++ /dev/null @@ -1 +0,0 @@ -const a = new Map(); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/options.json deleted file mode 100644 index d7dca0ca75ef..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/options.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "validateLogs": true, - "presets": [ - [ - "../../../../lib", - { - "configPath": "../fixtures/preset-options-add-used-built-ins/browserslist-config-ignore", - "modules": false, - "targets": { "esmodules": true }, - "useBuiltIns": "usage", - "corejs": 2, - "debug": true - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/output.mjs deleted file mode 100644 index 71719adea2ca..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/output.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "core-js/modules/web.dom.iterable"; -var a = new Map(); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/stdout.txt b/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/stdout.txt deleted file mode 100644 index 410ffbe544f7..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/stdout.txt +++ /dev/null @@ -1,42 +0,0 @@ -@babel/preset-env: `DEBUG` option - -Using targets: -{ - "android": "61", - "chrome": "61", - "edge": "16", - "firefox": "60", - "ios": "10.3", - "node": "13.2", - "opera": "48", - "safari": "10.1", - "samsung": "8.2" -} - -Using modules transform: false - -Using plugins: - proposal-numeric-separator { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "opera":"48", "safari":"10.1", "samsung":"8.2" } - proposal-logical-assignment-operators { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "node":"13.2", "opera":"48", "safari":"10.1", "samsung":"8.2" } - proposal-nullish-coalescing-operator { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "node":"13.2", "opera":"48", "safari":"10.1", "samsung":"8.2" } - proposal-optional-chaining { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "node":"13.2", "opera":"48", "safari":"10.1", "samsung":"8.2" } - proposal-json-strings { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "opera":"48", "safari":"10.1", "samsung":"8.2" } - proposal-optional-catch-binding { "android":"61", "chrome":"61", "edge":"16", "ios":"10.3", "opera":"48", "safari":"10.1", "samsung":"8.2" } - transform-parameters { "edge":"16" } - proposal-async-generator-functions { "android":"61", "chrome":"61", "edge":"16", "ios":"10.3", "opera":"48", "safari":"10.1" } - proposal-object-rest-spread { "edge":"16", "ios":"10.3", "safari":"10.1" } - transform-dotall-regex { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "opera":"48", "safari":"10.1" } - proposal-unicode-property-regex { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "opera":"48", "safari":"10.1", "samsung":"8.2" } - transform-named-capturing-groups-regex { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "opera":"48", "safari":"10.1", "samsung":"8.2" } - transform-async-to-generator { "ios":"10.3", "safari":"10.1" } - transform-template-literals { "ios":"10.3", "safari":"10.1" } - transform-function-name { "edge":"16" } - transform-unicode-regex { "ios":"10.3", "safari":"10.1" } - transform-block-scoping { "ios":"10.3", "safari":"10.1" } - proposal-export-namespace-from { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "opera":"48", "safari":"10.1", "samsung":"8.2" } - syntax-dynamic-import { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "node":"13.2", "opera":"48", "safari":"10.1", "samsung":"8.2" } - -Using polyfills with `usage` option: - -[/packages/babel-preset-env/test/fixtures/corejs2/usage-browserslist-config-ignore/input.mjs] Added following core-js polyfill: - web.dom.iterable { "android":"61", "chrome":"61", "edge":"16", "firefox":"60", "ios":"10.3", "node":"13.2", "opera":"48", "safari":"10.1", "samsung":"8.2" } diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/input.mjs deleted file mode 100644 index bf62d9f7518e..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/input.mjs +++ /dev/null @@ -1 +0,0 @@ -[a, b] = c; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/options.json deleted file mode 100644 index e58bc7432b89..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-destructuring"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/output.mjs deleted file mode 100644 index bf62d9f7518e..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-assignment/output.mjs +++ /dev/null @@ -1 +0,0 @@ -[a, b] = c; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/input.mjs deleted file mode 100644 index cb50832b47e8..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -try { - a(); -} catch([b, c]) { } diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/options.json deleted file mode 100644 index e58bc7432b89..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-destructuring"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/output.mjs deleted file mode 100644 index 830d37b8507d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-catch/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -try { - a(); -} catch ([b, c]) {} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/input.mjs deleted file mode 100644 index 027d407b5e83..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/input.mjs +++ /dev/null @@ -1 +0,0 @@ -for (let [a, b] in c); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/options.json deleted file mode 100644 index e58bc7432b89..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-destructuring"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/output.mjs deleted file mode 100644 index ca32ae08c5e2..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-for-x/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -for (var [a, b] in c) { - ; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/input.mjs deleted file mode 100644 index 0b8c72fe4c58..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/input.mjs +++ /dev/null @@ -1 +0,0 @@ -function a([b, c]) {} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/options.json deleted file mode 100644 index e58bc7432b89..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-destructuring"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/output.mjs deleted file mode 100644 index db332778ee99..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-params/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -function a(_ref) { - var [b, c] = _ref; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/input.mjs deleted file mode 100644 index e68aeb23a87b..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/input.mjs +++ /dev/null @@ -1 +0,0 @@ -const [a, b] = c; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/options.json deleted file mode 100644 index e58bc7432b89..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-destructuring"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/output.mjs deleted file mode 100644 index 6f950af748b7..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-destructuring-variable-declaration/output.mjs +++ /dev/null @@ -1 +0,0 @@ -var [a, b] = c; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/input.mjs deleted file mode 100644 index c12f5e3a8adb..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/input.mjs +++ /dev/null @@ -1,12 +0,0 @@ -var objectClass = Object; -var arrayInstance = []; -var assignStr = "assign"; -var entriesStr = "entries"; -var valuesStr = "values"; -var inclidesStr = "includes"; -var findStr = "find"; - -// Allow static methods be assigned to variables only directly in the module. -externalVar[valuesStr]; // don't include -objectClass[assignStr]({}); // include -arrayInstance[entriesStr]({}); // don't include diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/output.mjs deleted file mode 100644 index 113f840cdd16..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-class-methods/output.mjs +++ /dev/null @@ -1,17 +0,0 @@ -import "core-js/modules/es6.object.assign"; -import "core-js/modules/web.dom.iterable"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.object.to-string"; -var objectClass = Object; -var arrayInstance = []; -var assignStr = "assign"; -var entriesStr = "entries"; -var valuesStr = "values"; -var inclidesStr = "includes"; -var findStr = "find"; // Allow static methods be assigned to variables only directly in the module. - -externalVar[valuesStr]; // don't include - -objectClass[assignStr]({}); // include - -arrayInstance[entriesStr]({}); // don't include diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/input.mjs deleted file mode 100644 index 369046bb1597..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/input.mjs +++ /dev/null @@ -1,8 +0,0 @@ -var arrayInstance = []; -var inclidesStr = "includes"; -var findStr = "find"; - -// Allow instance methods be assigned to variables. -arrayInstance[inclidesStr](); // include -externalVar[findStr]; // include - diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/output.mjs deleted file mode 100644 index 726b4b40a3b6..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-instance-methods/output.mjs +++ /dev/null @@ -1,9 +0,0 @@ -import "core-js/modules/es6.array.find"; -import "core-js/modules/es7.array.includes"; -var arrayInstance = []; -var inclidesStr = "includes"; -var findStr = "find"; // Allow instance methods be assigned to variables. - -arrayInstance[inclidesStr](); // include - -externalVar[findStr]; // include diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/input.mjs deleted file mode 100644 index 279b65c0b53e..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/input.mjs +++ /dev/null @@ -1,5 +0,0 @@ -Object['values'](); // include -[]['map'](); // include - -Object[keys](); // don't include -[][filter](); // don't include diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/output.mjs deleted file mode 100644 index dfd826b75852..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-evaluated-not-confident/output.mjs +++ /dev/null @@ -1,12 +0,0 @@ -import "core-js/modules/es6.array.map"; -import "core-js/modules/web.dom.iterable"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es7.object.values"; -Object['values'](); // include - -[]['map'](); // include - -Object[keys](); // don't include - -[][filter](); // don't include diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/input.mjs deleted file mode 100644 index c9f54a8e47d2..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -for (const { padStart } of foo) { - console.log('b'.padEnd(5)); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/options.json deleted file mode 100644 index 53c96ff4219d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "node": "7" - }, - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/output.mjs deleted file mode 100644 index 6762f8384120..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-with/output.mjs +++ /dev/null @@ -1,8 +0,0 @@ -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.pad-start"; - -for (const { - padStart -} of foo) { - console.log('b'.padEnd(5)); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/input.mjs deleted file mode 100644 index 4228bde23c50..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -for (const { a } of foo) { - console.log(a); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/options.json deleted file mode 100644 index ec23cad4bdce..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "node": "11" - }, - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/output.mjs deleted file mode 100644 index 9b8c02b13b8d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of-destructure-without/output.mjs +++ /dev/null @@ -1,5 +0,0 @@ -for (const { - a -} of foo) { - console.log(a); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/input.mjs deleted file mode 100644 index 9f6660a25f8a..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/input.mjs +++ /dev/null @@ -1 +0,0 @@ -for (let a of b); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/options.json deleted file mode 100644 index ef3d4db9f278..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-for-of"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/output.mjs deleted file mode 100644 index 0399fdab41a1..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-for-of/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -for (var a of b) { - ; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/input.mjs deleted file mode 100644 index 35cd0f9960af..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/input.mjs +++ /dev/null @@ -1,12 +0,0 @@ -Array.from; // static function -Map; // top level built-in - -// instance methods may have false positives (which is ok) -a.includes(); // method call -b['find'] // computed string? -c.prototype.findIndex(); // .prototype -d.fill.bind(); //.bind -e.padStart.apply(); // .apply -f.padEnd.call(); // .call -String.prototype.startsWith.call; // prototype.call -var { codePointAt, endsWith } = k; // destructuring diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/options.json deleted file mode 100644 index de79358da292..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "targets": { - "chrome": 71 - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/output.mjs deleted file mode 100644 index 98577785b4fe..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods-native-support/output.mjs +++ /dev/null @@ -1,24 +0,0 @@ -import "core-js/modules/web.dom.iterable"; -Array.from; // static function - -Map; // top level built-in -// instance methods may have false positives (which is ok) - -a.includes(); // method call - -b['find']; // computed string? - -c.prototype.findIndex(); // .prototype - -d.fill.bind(); //.bind - -e.padStart.apply(); // .apply - -f.padEnd.call(); // .call - -String.prototype.startsWith.call; // prototype.call - -var { - codePointAt, - endsWith -} = k; // destructuring diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/input.mjs deleted file mode 100644 index 4528eff880c4..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/input.mjs +++ /dev/null @@ -1,20 +0,0 @@ -Array.from; // static function -Map; // top level built-in - -// instance methods may have false positives (which is ok) -a.includes(); // method call -b['find'] // computed string? -c.prototype.findIndex(); // .prototype -d.fill.bind(); //.bind -e.padStart.apply(); // .apply -f.padEnd.call(); // .call -String.prototype.startsWith.call; // prototype.call -var { codePointAt, endsWith } = k; // destructuring - -var asdf = "copyWithin"; -var asdf2 = "split"; -var asdf3 = "re" + "place"; -i[asdf]; // computed with identifier -j[`search`]; // computed with template -k[asdf3] // computed with concat strings -var { [asdf2]: _a } = k; // computed diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/output.mjs deleted file mode 100644 index e0f8fc879b64..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-instance-methods/output.mjs +++ /dev/null @@ -1,55 +0,0 @@ -import "core-js/modules/es6.regexp.split"; -import "core-js/modules/es6.regexp.replace"; -import "core-js/modules/es6.regexp.search"; -import "core-js/modules/es6.array.copy-within"; -import "core-js/modules/es6.string.ends-with"; -import "core-js/modules/es6.string.code-point-at"; -import "core-js/modules/es6.string.starts-with"; -import "core-js/modules/es7.string.pad-end"; -import "core-js/modules/es7.string.pad-start"; -import "core-js/modules/es6.array.fill"; -import "core-js/modules/es6.function.bind"; -import "core-js/modules/es6.array.find-index"; -import "core-js/modules/es6.array.find"; -import "core-js/modules/es7.array.includes"; -import "core-js/modules/es6.string.includes"; -import "core-js/modules/web.dom.iterable"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.object.to-string"; -import "core-js/modules/es6.map"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.array.from"; -Array.from; // static function - -Map; // top level built-in -// instance methods may have false positives (which is ok) - -a.includes(); // method call - -b['find']; // computed string? - -c.prototype.findIndex(); // .prototype - -d.fill.bind(); //.bind - -e.padStart.apply(); // .apply - -f.padEnd.call(); // .call - -String.prototype.startsWith.call; // prototype.call - -var _k = k, - codePointAt = _k.codePointAt, - endsWith = _k.endsWith; // destructuring - -var asdf = "copyWithin"; -var asdf2 = "split"; -var asdf3 = "re" + "place"; -i[asdf]; // computed with identifier - -j["search"]; // computed with template - -k[asdf3]; // computed with concat strings - -var _k2 = k, - _a = _k2[asdf2]; // computed diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/input.mjs deleted file mode 100644 index 3f57abb6052e..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import * as ns from "ns"; -ns.map; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/options.json deleted file mode 100644 index 429ee132c960..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "modules": false, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/output.mjs deleted file mode 100644 index 4efb9b0a495f..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-namespaced/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -import * as ns from "ns"; -ns.map; - diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/input.mjs deleted file mode 100644 index a2b81d72e3d5..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/input.mjs +++ /dev/null @@ -1 +0,0 @@ -Promise; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/options.json deleted file mode 100644 index 32ed21fb6f92..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/options.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/output.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/output.js deleted file mode 100644 index 4a62ea9e8164..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-modules-transform/output.js +++ /dev/null @@ -1,7 +0,0 @@ -"use strict"; - -require("core-js/modules/es6.promise"); - -require("core-js/modules/es6.object.to-string"); - -Promise; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/input.mjs deleted file mode 100644 index 68285538d365..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/input.mjs +++ /dev/null @@ -1,25 +0,0 @@ -Array.from; // static method -Map; // built-in -new Promise(); // new builtin -Symbol.match; // as member expression - -// no import -Array.asdf; -Array2.from; -Map2; -new Promise2(); -Symbol.asdf; -Symbol2.match; -_arr9[Symbol2.iterator](); -_arr9[Symbol.iterator2](); - -G.assign; // static method -function H(WeakMap) { - var blah = new WeakMap(); -} // shadowed - -// not covered by this plugin -var asdf = 'copyWithin'; -i[asdf]; // computed with identifier -j[`copyWithin`]; // computed with template -var { [asdf]: _a } = k; // computed diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/options.json deleted file mode 100644 index de79358da292..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "targets": { - "chrome": 71 - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/output.mjs deleted file mode 100644 index 845aac57c5c0..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-native-support/output.mjs +++ /dev/null @@ -1,37 +0,0 @@ -import "core-js/modules/web.dom.iterable"; -Array.from; // static method - -Map; // built-in - -new Promise(); // new builtin - -Symbol.match; // as member expression -// no import - -Array.asdf; -Array2.from; -Map2; -new Promise2(); -Symbol.asdf; -Symbol2.match; - -_arr9[Symbol2.iterator](); - -_arr9[Symbol.iterator2](); - -G.assign; // static method - -function H(WeakMap) { - var blah = new WeakMap(); -} // shadowed -// not covered by this plugin - - -var asdf = 'copyWithin'; -i[asdf]; // computed with identifier - -j[`copyWithin`]; // computed with template - -var { - [asdf]: _a -} = k; // computed diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/input.mjs deleted file mode 100644 index f688910ec093..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/input.mjs +++ /dev/null @@ -1 +0,0 @@ -var a = 1; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/output.mjs deleted file mode 100644 index f688910ec093..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-builtins/output.mjs +++ /dev/null @@ -1 +0,0 @@ -var a = 1; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/input.mjs deleted file mode 100644 index 31f2d79f9abb..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "not-core-js"; -import "not-babel-polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/options.json deleted file mode 100644 index ff036632375c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "chrome": "55" - }, - "modules": false, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/output.mjs deleted file mode 100644 index 31f2d79f9abb..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-no-transform/output.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "not-core-js"; -import "not-babel-polyfill"; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/input.mjs deleted file mode 100644 index f71c85f35e63..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/input.mjs +++ /dev/null @@ -1,2 +0,0 @@ -Number.parseFloat("3.14"); -Number.parseInt("10"); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/options.json deleted file mode 100644 index e793b91733df..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "ie": "11" - }, - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/output.mjs deleted file mode 100644 index 7e47082d45e4..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-number-ie-11/output.mjs +++ /dev/null @@ -1,5 +0,0 @@ -import "core-js/modules/es6.number.parse-int"; -import "core-js/modules/es6.number.constructor"; -import "core-js/modules/es6.number.parse-float"; -Number.parseFloat("3.14"); -Number.parseInt("10"); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/input.mjs deleted file mode 100644 index 0fef928e163d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/input.mjs +++ /dev/null @@ -1,4 +0,0 @@ -var p = Promise.resolve(0); -Promise.all([p]).then(outcome => { - alert("OK"); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/options.json deleted file mode 100644 index 133e1e9298dc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "browsers": ["ie > 10"] - }, - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/output.mjs deleted file mode 100644 index 199377053c8a..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-all/output.mjs +++ /dev/null @@ -1,9 +0,0 @@ -import "core-js/modules/web.dom.iterable"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es6.object.to-string"; -var p = Promise.resolve(0); -Promise.all([p]).then(function (outcome) { - alert("OK"); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/input.mjs deleted file mode 100644 index bb634febe9b9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/input.mjs +++ /dev/null @@ -1,4 +0,0 @@ -var p = Promise.resolve(0); -p.finally(() => { - alert("OK"); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/options.json deleted file mode 100644 index 133e1e9298dc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "browsers": ["ie > 10"] - }, - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/output.mjs deleted file mode 100644 index a2103a5120a2..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-finally/output.mjs +++ /dev/null @@ -1,7 +0,0 @@ -import "core-js/modules/es7.promise.finally"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es6.object.to-string"; -var p = Promise.resolve(0); -p.finally(function () { - alert("OK"); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/input.mjs deleted file mode 100644 index 334252838bc0..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/input.mjs +++ /dev/null @@ -1,4 +0,0 @@ -var p = Promise.resolve(0); -Promise.race([p]).then(outcome => { - alert("OK"); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/options.json deleted file mode 100644 index 133e1e9298dc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "targets": { - "browsers": ["ie > 10"] - }, - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/output.mjs deleted file mode 100644 index b4a03612d049..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-promise-race/output.mjs +++ /dev/null @@ -1,9 +0,0 @@ -import "core-js/modules/web.dom.iterable"; -import "core-js/modules/es6.array.iterator"; -import "core-js/modules/es6.string.iterator"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es6.object.to-string"; -var p = Promise.resolve(0); -Promise.race([p]).then(function (outcome) { - alert("OK"); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/input.mjs deleted file mode 100644 index 8f6724b27f04..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/input.mjs +++ /dev/null @@ -1 +0,0 @@ -async function a(){} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/options.json deleted file mode 100644 index a1b9ada1e85c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "targets": { - "chrome": 70 - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/output.mjs deleted file mode 100644 index 5d965c6200a9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-and-promise-native-support/output.mjs +++ /dev/null @@ -1 +0,0 @@ -async function a() {} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/input.mjs deleted file mode 100644 index 8f6724b27f04..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/input.mjs +++ /dev/null @@ -1 +0,0 @@ -async function a(){} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/options.json deleted file mode 100644 index d5fc31f1549d..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "targets": { - "chrome": 55 - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/output.mjs deleted file mode 100644 index 5d965c6200a9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async-native-support/output.mjs +++ /dev/null @@ -1 +0,0 @@ -async function a() {} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/input.mjs deleted file mode 100644 index 8f6724b27f04..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/input.mjs +++ /dev/null @@ -1 +0,0 @@ -async function a(){} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/output.mjs deleted file mode 100644 index d6e9c55f3e2b..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-async/output.mjs +++ /dev/null @@ -1,26 +0,0 @@ -import "regenerator-runtime/runtime"; -import "core-js/modules/es6.promise"; -import "core-js/modules/es6.object.to-string"; - -function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } - -function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } - -function a() { - return _a.apply(this, arguments); -} - -function _a() { - _a = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { - return regeneratorRuntime.wrap(function _callee$(_context) { - while (1) { - switch (_context.prev = _context.next) { - case 0: - case "end": - return _context.stop(); - } - } - }, _callee); - })); - return _a.apply(this, arguments); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/input.mjs deleted file mode 100644 index 4df46943d261..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/input.mjs +++ /dev/null @@ -1 +0,0 @@ -function* a() {} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/options.json deleted file mode 100644 index 2386a9041077..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "targets": { - "node": 6 - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/output.mjs deleted file mode 100644 index 4df46943d261..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator-native-support/output.mjs +++ /dev/null @@ -1 +0,0 @@ -function* a() {} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/input.mjs deleted file mode 100644 index 74604e9198f6..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/input.mjs +++ /dev/null @@ -1 +0,0 @@ -function* a(){} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/output.mjs deleted file mode 100644 index 62d15abf1f61..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-regenerator-used-generator/output.mjs +++ /dev/null @@ -1,15 +0,0 @@ -import "regenerator-runtime/runtime"; - -var _marked = /*#__PURE__*/regeneratorRuntime.mark(a); - -function a() { - return regeneratorRuntime.wrap(function a$(_context) { - while (1) { - switch (_context.prev = _context.next) { - case 0: - case "end": - return _context.stop(); - } - } - }, _marked); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/input.mjs deleted file mode 100644 index 9497c399adf1..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/input.mjs +++ /dev/null @@ -1,4 +0,0 @@ -import "@babel/polyfill"; -import "@babel/polyfill"; -require("@babel/polyfill"); -require("@babel/polyfill"); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/options.json deleted file mode 100644 index 71b68e4379e7..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "validateLogs": true, - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/stderr.txt b/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/stderr.txt deleted file mode 100644 index 6234fa874573..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/stderr.txt +++ /dev/null @@ -1,11 +0,0 @@ -When setting `useBuiltIns: 'usage'`, polyfills are automatically imported when needed. - Please remove the `import '@babel/polyfill'` call or use `useBuiltIns: 'entry'` instead. - - When setting `useBuiltIns: 'usage'`, polyfills are automatically imported when needed. - Please remove the `import '@babel/polyfill'` call or use `useBuiltIns: 'entry'` instead. - - When setting `useBuiltIns: 'usage'`, polyfills are automatically imported when needed. - Please remove the `import '@babel/polyfill'` call or use `useBuiltIns: 'entry'` instead. - - When setting `useBuiltIns: 'usage'`, polyfills are automatically imported when needed. - Please remove the `import '@babel/polyfill'` call or use `useBuiltIns: 'entry'` instead. diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/input.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/input.js deleted file mode 100644 index d95854b64f8c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/input.js +++ /dev/null @@ -1,6 +0,0 @@ -let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 }; -let n = { x, y, ...z }; -async function* agf() { - await 1; - yield 2; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/options.json deleted file mode 100644 index 1ff3addd4982..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "sourceType": "module", - "presets": [ - [ - "../../../../lib", - { - "shippedProposals": true, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/output.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/output.js deleted file mode 100644 index 0494407264d1..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-shippedProposals/output.js +++ /dev/null @@ -1,97 +0,0 @@ -"use strict"; - -require("core-js/modules/es6.object.define-properties"); - -require("core-js/modules/es7.object.get-own-property-descriptors"); - -require("core-js/modules/es6.array.for-each"); - -require("core-js/modules/es6.array.filter"); - -require("core-js/modules/es6.object.define-property"); - -require("core-js/modules/es6.array.index-of"); - -require("core-js/modules/web.dom.iterable"); - -require("core-js/modules/es6.array.iterator"); - -require("core-js/modules/es6.object.keys"); - -require("regenerator-runtime/runtime"); - -require("core-js/modules/es7.symbol.async-iterator"); - -require("core-js/modules/es6.symbol"); - -require("core-js/modules/es6.promise"); - -require("core-js/modules/es6.object.to-string"); - -function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } - -function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } - -function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } - -function _awaitAsyncGenerator(value) { return new _AwaitValue(value); } - -function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; } - -function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen["return"] !== "function") { this["return"] = undefined; } } - -if (typeof Symbol === "function" && Symbol.asyncIterator) { _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; }; } - -_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); }; - -_AsyncGenerator.prototype["throw"] = function (arg) { return this._invoke("throw", arg); }; - -_AsyncGenerator.prototype["return"] = function (arg) { return this._invoke("return", arg); }; - -function _AwaitValue(value) { this.wrapped = value; } - -var _x$y$a$b = { - x: 1, - y: 2, - a: 3, - b: 4 -}, - x = _x$y$a$b.x, - y = _x$y$a$b.y, - z = _objectWithoutProperties(_x$y$a$b, ["x", "y"]); - -var n = _objectSpread({ - x: x, - y: y -}, z); - -function agf() { - return _agf.apply(this, arguments); -} - -function _agf() { - _agf = _wrapAsyncGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { - return regeneratorRuntime.wrap(function _callee$(_context) { - while (1) { - switch (_context.prev = _context.next) { - case 0: - _context.next = 2; - return _awaitAsyncGenerator(1); - - case 2: - _context.next = 4; - return 2; - - case 4: - case "end": - return _context.stop(); - } - } - }, _callee); - })); - return _agf.apply(this, arguments); -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/input.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/input.js deleted file mode 100644 index 39f9e5858b8c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/input.js +++ /dev/null @@ -1,8 +0,0 @@ -require("foo"); - -const x = new Promise(resolve => { - const p = []; - - if (p.includes("a")) { - } -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/options.json deleted file mode 100644 index 5bf97a806ec8..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/options.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "modules": false, - "targets": { - "node": "4.0.0" - }, - "useBuiltIns": "usage", - "corejs": 2, - "shippedProposals": true - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/output.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/output.js deleted file mode 100644 index 6f953a53d427..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script-query/output.js +++ /dev/null @@ -1,13 +0,0 @@ -require("core-js/modules/es7.array.includes"); - -require("core-js/modules/es6.promise"); - -require("core-js/modules/es6.object.to-string"); - -require("foo"); - -var x = new Promise(function (resolve) { - var p = []; - - if (p.includes("a")) {} -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/input.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/input.js deleted file mode 100644 index 39f9e5858b8c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/input.js +++ /dev/null @@ -1,8 +0,0 @@ -require("foo"); - -const x = new Promise(resolve => { - const p = []; - - if (p.includes("a")) { - } -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/options.json deleted file mode 100644 index 5bf97a806ec8..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/options.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "modules": false, - "targets": { - "node": "4.0.0" - }, - "useBuiltIns": "usage", - "corejs": 2, - "shippedProposals": true - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/output.js b/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/output.js deleted file mode 100644 index 6f953a53d427..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-source-type-script/output.js +++ /dev/null @@ -1,13 +0,0 @@ -require("core-js/modules/es7.array.includes"); - -require("core-js/modules/es6.promise"); - -require("core-js/modules/es6.object.to-string"); - -require("foo"); - -var x = new Promise(function (resolve) { - var p = []; - - if (p.includes("a")) {} -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/input.mjs deleted file mode 100644 index 457ddbbd55fe..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/input.mjs +++ /dev/null @@ -1 +0,0 @@ -a = [b, ...c]; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/options.json deleted file mode 100644 index fe86765f3810..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/options.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false, - "exclude": ["transform-spread"] - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/output.mjs deleted file mode 100644 index 457ddbbd55fe..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-spread/output.mjs +++ /dev/null @@ -1 +0,0 @@ -a = [b, ...c]; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/input.mjs deleted file mode 100644 index 3d72e8e71cf1..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/input.mjs +++ /dev/null @@ -1 +0,0 @@ -Symbol.iterator in arr diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/output.mjs deleted file mode 100644 index 024e49245f9c..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator-in/output.mjs +++ /dev/null @@ -1,4 +0,0 @@ -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/web.dom.iterable"; -Symbol.iterator in arr; diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/input.mjs deleted file mode 100644 index c44a50ddfddc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/input.mjs +++ /dev/null @@ -1 +0,0 @@ -arr[Symbol.iterator]() diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/output.mjs deleted file mode 100644 index a99eae6b7eb3..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-symbol-iterator/output.mjs +++ /dev/null @@ -1,4 +0,0 @@ -import "core-js/modules/es7.symbol.async-iterator"; -import "core-js/modules/es6.symbol"; -import "core-js/modules/web.dom.iterable"; -arr[Symbol.iterator](); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/input.mjs deleted file mode 100644 index 0f5be0d2da0e..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/input.mjs +++ /dev/null @@ -1,5 +0,0 @@ -Promise.resolve().then(it => { - setTimeout(foo, 1, 2); - setInterval(foo, 1, 2); - setImmediate(foo, 1, 2); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/output.mjs deleted file mode 100644 index 9f0806068bfb..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-timers/output.mjs +++ /dev/null @@ -1,7 +0,0 @@ -import "core-js/modules/es6.promise"; -import "core-js/modules/es6.object.to-string"; -Promise.resolve().then(function (it) { - setTimeout(foo, 1, 2); - setInterval(foo, 1, 2); - setImmediate(foo, 1, 2); -}); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/input.mjs deleted file mode 100644 index b0bc068aa063..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/input.mjs +++ /dev/null @@ -1 +0,0 @@ -new Int8Array(1); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/options.json deleted file mode 100644 index 057e2ed59be0..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "targets": { - "edge": "13" - }, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/output.mjs deleted file mode 100644 index b0bc068aa063..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-edge-13/output.mjs +++ /dev/null @@ -1 +0,0 @@ -new Int8Array(1); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/input.mjs deleted file mode 100644 index 2394d067f859..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/input.mjs +++ /dev/null @@ -1 +0,0 @@ -Int8Array.of(); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/output.mjs deleted file mode 100644 index 995d901c5ced..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array-static/output.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "core-js/modules/es6.typed.int8-array"; -Int8Array.of(); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/input.mjs deleted file mode 100644 index b0bc068aa063..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/input.mjs +++ /dev/null @@ -1 +0,0 @@ -new Int8Array(1); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/options.json deleted file mode 100644 index fe3e4d6cf9c9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/options.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/output.mjs deleted file mode 100644 index 5f5982426d2b..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-typed-array/output.mjs +++ /dev/null @@ -1,2 +0,0 @@ -import "core-js/modules/es6.typed.int8-array"; -new Int8Array(1); diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/input.mjs deleted file mode 100644 index 927d2f2772bc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield 1; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/options.json deleted file mode 100644 index dae54735f2d9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "targets": { - "chrome": 55 - }, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/output.mjs deleted file mode 100644 index 927d2f2772bc..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-non-star/output.mjs +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield 1; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/input.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/input.mjs deleted file mode 100644 index 4915d62092eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/input.mjs +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/options.json b/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/options.json deleted file mode 100644 index dae54735f2d9..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "presets": [ - [ - "../../../../lib", - { - "useBuiltIns": "usage", - "corejs": 2, - "targets": { - "chrome": 55 - }, - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/output.mjs b/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/output.mjs deleted file mode 100644 index 25cd531c2235..000000000000 --- a/packages/babel-preset-env/test/fixtures/corejs2/usage-yield-star/output.mjs +++ /dev/null @@ -1,5 +0,0 @@ -import "core-js/modules/web.dom.iterable"; - -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/options.json deleted file mode 100644 index 7c23631533a1..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "browsers": ["Android >= 4"] - }, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/stdout.txt deleted file mode 100644 index b78d7f4368b0..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/stdout.txt +++ /dev/null @@ -1,166 +0,0 @@ -@babel/preset-env: `DEBUG` option - -Using targets: -{ - "android": "4" -} - -Using modules transform: auto - -Using plugins: - proposal-numeric-separator { "android":"4" } - proposal-logical-assignment-operators { "android":"4" } - proposal-nullish-coalescing-operator { "android":"4" } - proposal-optional-chaining { "android":"4" } - proposal-json-strings { "android":"4" } - proposal-optional-catch-binding { "android":"4" } - transform-parameters { "android":"4" } - proposal-async-generator-functions { "android":"4" } - proposal-object-rest-spread { "android":"4" } - transform-dotall-regex { "android":"4" } - proposal-unicode-property-regex { "android":"4" } - transform-named-capturing-groups-regex { "android":"4" } - transform-async-to-generator { "android":"4" } - transform-exponentiation-operator { "android":"4" } - transform-template-literals { "android":"4" } - transform-literals { "android":"4" } - transform-function-name { "android":"4" } - transform-arrow-functions { "android":"4" } - transform-block-scoped-functions { "android":"4" } - transform-classes { "android":"4" } - transform-object-super { "android":"4" } - transform-shorthand-properties { "android":"4" } - transform-duplicate-keys { "android":"4" } - transform-computed-properties { "android":"4" } - transform-for-of { "android":"4" } - transform-sticky-regex { "android":"4" } - transform-unicode-escapes { "android":"4" } - transform-unicode-regex { "android":"4" } - transform-spread { "android":"4" } - transform-destructuring { "android":"4" } - transform-block-scoping { "android":"4" } - transform-typeof-symbol { "android":"4" } - transform-new-target { "android":"4" } - transform-regenerator { "android":"4" } - transform-reserved-words { "android":"4" } - proposal-export-namespace-from { "android":"4" } - transform-modules-commonjs { "android":"4" } - proposal-dynamic-import { "android":"4" } - -Using polyfills with `entry` option: - -[/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-android/input.mjs] Replaced @babel/polyfill entries with the following polyfills: - es6.array.copy-within { "android":"4" } - es6.array.fill { "android":"4" } - es6.array.find { "android":"4" } - es6.array.find-index { "android":"4" } - es7.array.flat-map { "android":"4" } - es6.array.from { "android":"4" } - es7.array.includes { "android":"4" } - es6.array.iterator { "android":"4" } - es6.array.of { "android":"4" } - es6.array.sort { "android":"4" } - es6.array.species { "android":"4" } - es6.date.to-primitive { "android":"4" } - es6.function.has-instance { "android":"4" } - es6.map { "android":"4" } - es6.math.acosh { "android":"4" } - es6.math.asinh { "android":"4" } - es6.math.atanh { "android":"4" } - es6.math.cbrt { "android":"4" } - es6.math.clz32 { "android":"4" } - es6.math.cosh { "android":"4" } - es6.math.expm1 { "android":"4" } - es6.math.fround { "android":"4" } - es6.math.hypot { "android":"4" } - es6.math.imul { "android":"4" } - es6.math.log1p { "android":"4" } - es6.math.log10 { "android":"4" } - es6.math.log2 { "android":"4" } - es6.math.sign { "android":"4" } - es6.math.sinh { "android":"4" } - es6.math.tanh { "android":"4" } - es6.math.trunc { "android":"4" } - es6.number.constructor { "android":"4" } - es6.number.epsilon { "android":"4" } - es6.number.is-finite { "android":"4" } - es6.number.is-integer { "android":"4" } - es6.number.is-nan { "android":"4" } - es6.number.is-safe-integer { "android":"4" } - es6.number.max-safe-integer { "android":"4" } - es6.number.min-safe-integer { "android":"4" } - es6.number.parse-float { "android":"4" } - es6.number.parse-int { "android":"4" } - es6.object.assign { "android":"4" } - es7.object.define-getter { "android":"4" } - es7.object.define-setter { "android":"4" } - es7.object.entries { "android":"4" } - es6.object.freeze { "android":"4" } - es6.object.get-own-property-descriptor { "android":"4" } - es7.object.get-own-property-descriptors { "android":"4" } - es6.object.get-own-property-names { "android":"4" } - es6.object.get-prototype-of { "android":"4" } - es7.object.lookup-getter { "android":"4" } - es7.object.lookup-setter { "android":"4" } - es6.object.prevent-extensions { "android":"4" } - es6.object.to-string { "android":"4" } - es6.object.is { "android":"4" } - es6.object.is-frozen { "android":"4" } - es6.object.is-sealed { "android":"4" } - es6.object.is-extensible { "android":"4" } - es6.object.keys { "android":"4" } - es6.object.seal { "android":"4" } - es6.object.set-prototype-of { "android":"4" } - es7.object.values { "android":"4" } - es6.promise { "android":"4" } - es7.promise.finally { "android":"4" } - es6.reflect.apply { "android":"4" } - es6.reflect.construct { "android":"4" } - es6.reflect.define-property { "android":"4" } - es6.reflect.delete-property { "android":"4" } - es6.reflect.get { "android":"4" } - es6.reflect.get-own-property-descriptor { "android":"4" } - es6.reflect.get-prototype-of { "android":"4" } - es6.reflect.has { "android":"4" } - es6.reflect.is-extensible { "android":"4" } - es6.reflect.own-keys { "android":"4" } - es6.reflect.prevent-extensions { "android":"4" } - es6.reflect.set { "android":"4" } - es6.reflect.set-prototype-of { "android":"4" } - es6.regexp.constructor { "android":"4" } - es6.regexp.flags { "android":"4" } - es6.regexp.match { "android":"4" } - es6.regexp.replace { "android":"4" } - es6.regexp.split { "android":"4" } - es6.regexp.search { "android":"4" } - es6.regexp.to-string { "android":"4" } - es6.set { "android":"4" } - es6.symbol { "android":"4" } - es7.symbol.async-iterator { "android":"4" } - es6.string.code-point-at { "android":"4" } - es6.string.ends-with { "android":"4" } - es6.string.from-code-point { "android":"4" } - es6.string.includes { "android":"4" } - es6.string.iterator { "android":"4" } - es7.string.pad-start { "android":"4" } - es7.string.pad-end { "android":"4" } - es6.string.raw { "android":"4" } - es6.string.repeat { "android":"4" } - es6.string.starts-with { "android":"4" } - es7.string.trim-left { "android":"4" } - es7.string.trim-right { "android":"4" } - es6.typed.array-buffer { "android":"4" } - es6.typed.int8-array { "android":"4" } - es6.typed.uint8-array { "android":"4" } - es6.typed.uint8-clamped-array { "android":"4" } - es6.typed.int16-array { "android":"4" } - es6.typed.uint16-array { "android":"4" } - es6.typed.int32-array { "android":"4" } - es6.typed.uint32-array { "android":"4" } - es6.typed.float32-array { "android":"4" } - es6.typed.float64-array { "android":"4" } - es6.weak-map { "android":"4" } - es6.weak-set { "android":"4" } - web.timers { "android":"4" } - web.immediate { "android":"4" } - web.dom.iterable { "android":"4" } diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/options.json deleted file mode 100644 index 87ebef4f6836..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "electron": 0.36 - }, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/stdout.txt deleted file mode 100644 index 168d8138f3a6..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/stdout.txt +++ /dev/null @@ -1,104 +0,0 @@ -Warning, the following targets are using a decimal version: - - electron: 0.36 - -We recommend using a string for minor/patch versions to avoid numbers like 6.10 -getting parsed as 6.1, which can lead to unexpected behavior. - -@babel/preset-env: `DEBUG` option - -Using targets: -{ - "electron": "0.36" -} - -Using modules transform: auto - -Using plugins: - proposal-numeric-separator { "electron":"0.36" } - proposal-logical-assignment-operators { "electron":"0.36" } - proposal-nullish-coalescing-operator { "electron":"0.36" } - proposal-optional-chaining { "electron":"0.36" } - proposal-json-strings { "electron":"0.36" } - proposal-optional-catch-binding { "electron":"0.36" } - transform-parameters { "electron":"0.36" } - proposal-async-generator-functions { "electron":"0.36" } - proposal-object-rest-spread { "electron":"0.36" } - transform-dotall-regex { "electron":"0.36" } - proposal-unicode-property-regex { "electron":"0.36" } - transform-named-capturing-groups-regex { "electron":"0.36" } - transform-async-to-generator { "electron":"0.36" } - transform-exponentiation-operator { "electron":"0.36" } - transform-function-name { "electron":"0.36" } - transform-for-of { "electron":"0.36" } - transform-sticky-regex { "electron":"0.36" } - transform-unicode-regex { "electron":"0.36" } - transform-destructuring { "electron":"0.36" } - transform-block-scoping { "electron":"0.36" } - transform-regenerator { "electron":"0.36" } - proposal-export-namespace-from { "electron":"0.36" } - transform-modules-commonjs { "electron":"0.36" } - proposal-dynamic-import { "electron":"0.36" } - -Using polyfills with `entry` option: - -[/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-electron/input.mjs] Replaced @babel/polyfill entries with the following polyfills: - es7.array.flat-map { "electron":"0.36" } - es6.array.from { "electron":"0.36" } - es6.array.sort { "electron":"0.36" } - es6.array.species { "electron":"0.36" } - es6.function.has-instance { "electron":"0.36" } - es6.map { "electron":"0.36" } - es6.object.assign { "electron":"0.36" } - es7.object.define-getter { "electron":"0.36" } - es7.object.define-setter { "electron":"0.36" } - es7.object.entries { "electron":"0.36" } - es7.object.get-own-property-descriptors { "electron":"0.36" } - es7.object.lookup-getter { "electron":"0.36" } - es7.object.lookup-setter { "electron":"0.36" } - es6.object.to-string { "electron":"0.36" } - es7.object.values { "electron":"0.36" } - es6.promise { "electron":"0.36" } - es7.promise.finally { "electron":"0.36" } - es6.reflect.apply { "electron":"0.36" } - es6.reflect.construct { "electron":"0.36" } - es6.reflect.define-property { "electron":"0.36" } - es6.reflect.delete-property { "electron":"0.36" } - es6.reflect.get { "electron":"0.36" } - es6.reflect.get-own-property-descriptor { "electron":"0.36" } - es6.reflect.get-prototype-of { "electron":"0.36" } - es6.reflect.has { "electron":"0.36" } - es6.reflect.is-extensible { "electron":"0.36" } - es6.reflect.own-keys { "electron":"0.36" } - es6.reflect.prevent-extensions { "electron":"0.36" } - es6.reflect.set { "electron":"0.36" } - es6.reflect.set-prototype-of { "electron":"0.36" } - es6.regexp.constructor { "electron":"0.36" } - es6.regexp.flags { "electron":"0.36" } - es6.regexp.match { "electron":"0.36" } - es6.regexp.replace { "electron":"0.36" } - es6.regexp.split { "electron":"0.36" } - es6.regexp.search { "electron":"0.36" } - es6.regexp.to-string { "electron":"0.36" } - es6.set { "electron":"0.36" } - es6.symbol { "electron":"0.36" } - es7.symbol.async-iterator { "electron":"0.36" } - es7.string.pad-start { "electron":"0.36" } - es7.string.pad-end { "electron":"0.36" } - es7.string.trim-left { "electron":"0.36" } - es7.string.trim-right { "electron":"0.36" } - es6.typed.array-buffer { "electron":"0.36" } - es6.typed.int8-array { "electron":"0.36" } - es6.typed.uint8-array { "electron":"0.36" } - es6.typed.uint8-clamped-array { "electron":"0.36" } - es6.typed.int16-array { "electron":"0.36" } - es6.typed.uint16-array { "electron":"0.36" } - es6.typed.int32-array { "electron":"0.36" } - es6.typed.uint32-array { "electron":"0.36" } - es6.typed.float32-array { "electron":"0.36" } - es6.typed.float64-array { "electron":"0.36" } - es6.weak-map { "electron":"0.36" } - es6.weak-set { "electron":"0.36" } - web.timers { "electron":"0.36" } - web.immediate { "electron":"0.36" } - web.dom.iterable { "electron":"0.36" } diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-force-all-transforms/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-force-all-transforms/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-force-all-transforms/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-force-all-transforms/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-force-all-transforms/options.json deleted file mode 100644 index 63316b736f5c..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-force-all-transforms/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "modules": false, - "targets": { - "chrome": 55 - }, - "useBuiltIns": "entry", - "corejs": 2, - "forceAllTransforms": true - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-no-import/input.js b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-no-import/input.js deleted file mode 100644 index e31333abc597..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-no-import/input.js +++ /dev/null @@ -1 +0,0 @@ -function hasAnyoneSeenImportBabelPolyfill() { return false }; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-no-import/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-no-import/options.json deleted file mode 100644 index c1bb48f690fe..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-no-import/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "node": 6 - }, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals-chrome-71/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals-chrome-71/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals-chrome-71/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals-chrome-71/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals-chrome-71/options.json deleted file mode 100644 index c40fbcce5f07..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals-chrome-71/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "browsers": "chrome 71" - }, - "useBuiltIns": "entry", - "corejs": { "version": 2, "proposals": true } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals/options.json deleted file mode 100644 index b7911d7ee093..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-proposals/options.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "useBuiltIns": "entry", - "corejs": { "version": 2, "proposals": true } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals-chrome-71/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals-chrome-71/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals-chrome-71/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals-chrome-71/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals-chrome-71/options.json deleted file mode 100644 index eca9a1a6033d..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals-chrome-71/options.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "browsers": "chrome 71" - }, - "shippedProposals": true, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals/options.json deleted file mode 100644 index 7cc745ffc6f5..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-shippedProposals/options.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "shippedProposals": true, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-specific-targets/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-specific-targets/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-specific-targets/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-specific-targets/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-specific-targets/options.json deleted file mode 100644 index 2c036f8e4d1d..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-specific-targets/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "browsers": "ie 10, ios 9, safari 7, edge 13, chrome 54, firefox 49" - }, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-decimals/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-decimals/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-decimals/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-decimals/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-decimals/options.json deleted file mode 100644 index 637bfdfe8456..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-decimals/options.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "useBuiltIns": "entry", - "corejs": 2, - "debug": true, - "targets": { - "chrome": 54, - "electron": 0.36, - "node": 6.1, - "ie": 10 - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-strings/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-strings/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-strings/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-strings/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-strings/options.json deleted file mode 100644 index 7fcba34b836c..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2-versions-strings/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "useBuiltIns": "entry", - "corejs": 2, - "debug": true, - "targets": { - "chrome": "54", - "node": "6.10", - "ie": "10" - } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-corejs2/options.json deleted file mode 100644 index e8cc67c9ac8e..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-corejs2/options.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "browsers": "chrome >= 54, ie 10", - "node": 6 - }, - "useBuiltIns": "entry", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/input.js b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/input.js index e31333abc597..bc2584a8ad4f 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/input.js +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/input.js @@ -1 +1 @@ -function hasAnyoneSeenImportBabelPolyfill() { return false }; +function hasAnyoneSeenImportCoreJS() { return false }; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stderr.txt index dbee5e8f3eb3..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stdout.txt index 0720357318a4..bab734e37c19 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stdout.txt +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/stdout.txt @@ -30,4 +30,4 @@ Using plugins: Using polyfills with `entry` option: -[/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/input.js] Import of @babel/polyfill was not found. +[/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-no-import/input.js] Import of core-js was not found. diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/input.mjs index c3030bdd6280..66bfb4d1516b 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/input.mjs +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/input.mjs @@ -1 +1 @@ -import '@babel/polyfill'; +import 'core-js'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stderr.txt index dbee5e8f3eb3..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stdout.txt index c50a35891239..95194052eb98 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stdout.txt +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/stdout.txt @@ -51,152 +51,338 @@ Using plugins: Using polyfills with `entry` option: -[/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/input.mjs] Replaced @babel/polyfill entries with the following polyfills: - es6.array.copy-within {} - es6.array.every {} - es6.array.fill {} - es6.array.filter {} - es6.array.find {} - es6.array.find-index {} - es7.array.flat-map {} - es6.array.for-each {} - es6.array.from {} - es7.array.includes {} - es6.array.index-of {} - es6.array.is-array {} - es6.array.iterator {} - es6.array.last-index-of {} - es6.array.map {} - es6.array.of {} - es6.array.reduce {} - es6.array.reduce-right {} - es6.array.some {} - es6.array.sort {} - es6.array.species {} - es6.date.now {} - es6.date.to-iso-string {} - es6.date.to-json {} - es6.date.to-primitive {} - es6.date.to-string {} - es6.function.bind {} - es6.function.has-instance {} - es6.function.name {} - es6.map {} - es6.math.acosh {} - es6.math.asinh {} - es6.math.atanh {} - es6.math.cbrt {} - es6.math.clz32 {} - es6.math.cosh {} - es6.math.expm1 {} - es6.math.fround {} - es6.math.hypot {} - es6.math.imul {} - es6.math.log1p {} - es6.math.log10 {} - es6.math.log2 {} - es6.math.sign {} - es6.math.sinh {} - es6.math.tanh {} - es6.math.trunc {} - es6.number.constructor {} - es6.number.epsilon {} - es6.number.is-finite {} - es6.number.is-integer {} - es6.number.is-nan {} - es6.number.is-safe-integer {} - es6.number.max-safe-integer {} - es6.number.min-safe-integer {} - es6.number.parse-float {} - es6.number.parse-int {} - es6.object.assign {} - es6.object.create {} - es7.object.define-getter {} - es7.object.define-setter {} - es6.object.define-property {} - es6.object.define-properties {} - es7.object.entries {} - es6.object.freeze {} - es6.object.get-own-property-descriptor {} - es7.object.get-own-property-descriptors {} - es6.object.get-own-property-names {} - es6.object.get-prototype-of {} - es7.object.lookup-getter {} - es7.object.lookup-setter {} - es6.object.prevent-extensions {} - es6.object.to-string {} - es6.object.is {} - es6.object.is-frozen {} - es6.object.is-sealed {} - es6.object.is-extensible {} - es6.object.keys {} - es6.object.seal {} - es6.object.set-prototype-of {} - es7.object.values {} - es6.promise {} - es7.promise.finally {} - es6.reflect.apply {} - es6.reflect.construct {} - es6.reflect.define-property {} - es6.reflect.delete-property {} - es6.reflect.get {} - es6.reflect.get-own-property-descriptor {} - es6.reflect.get-prototype-of {} - es6.reflect.has {} - es6.reflect.is-extensible {} - es6.reflect.own-keys {} - es6.reflect.prevent-extensions {} - es6.reflect.set {} - es6.reflect.set-prototype-of {} - es6.regexp.constructor {} - es6.regexp.flags {} - es6.regexp.match {} - es6.regexp.replace {} - es6.regexp.split {} - es6.regexp.search {} - es6.regexp.to-string {} - es6.set {} - es6.symbol {} - es7.symbol.async-iterator {} - es6.string.anchor {} - es6.string.big {} - es6.string.blink {} - es6.string.bold {} - es6.string.code-point-at {} - es6.string.ends-with {} - es6.string.fixed {} - es6.string.fontcolor {} - es6.string.fontsize {} - es6.string.from-code-point {} - es6.string.includes {} - es6.string.italics {} - es6.string.iterator {} - es6.string.link {} - es7.string.pad-start {} - es7.string.pad-end {} - es6.string.raw {} - es6.string.repeat {} - es6.string.small {} - es6.string.starts-with {} - es6.string.strike {} - es6.string.sub {} - es6.string.sup {} - es6.string.trim {} - es7.string.trim-left {} - es7.string.trim-right {} - es6.typed.array-buffer {} - es6.typed.data-view {} - es6.typed.int8-array {} - es6.typed.uint8-array {} - es6.typed.uint8-clamped-array {} - es6.typed.int16-array {} - es6.typed.uint16-array {} - es6.typed.int32-array {} - es6.typed.uint32-array {} - es6.typed.float32-array {} - es6.typed.float64-array {} - es6.weak-map {} - es6.weak-set {} - web.timers {} +[/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-shippedProposals/input.mjs] Replaced core-js entries with the following polyfills: + es.symbol {} + es.symbol.description {} + es.symbol.async-iterator {} + es.symbol.has-instance {} + es.symbol.is-concat-spreadable {} + es.symbol.iterator {} + es.symbol.match {} + es.symbol.match-all {} + es.symbol.replace {} + es.symbol.search {} + es.symbol.species {} + es.symbol.split {} + es.symbol.to-primitive {} + es.symbol.to-string-tag {} + es.symbol.unscopables {} + es.array.concat {} + es.array.copy-within {} + es.array.every {} + es.array.fill {} + es.array.filter {} + es.array.find {} + es.array.find-index {} + es.array.flat {} + es.array.flat-map {} + es.array.for-each {} + es.array.from {} + es.array.includes {} + es.array.index-of {} + es.array.is-array {} + es.array.iterator {} + es.array.join {} + es.array.last-index-of {} + es.array.map {} + es.array.of {} + es.array.reduce {} + es.array.reduce-right {} + es.array.reverse {} + es.array.slice {} + es.array.some {} + es.array.sort {} + es.array.species {} + es.array.splice {} + es.array.unscopables.flat {} + es.array.unscopables.flat-map {} + es.array-buffer.constructor {} + es.array-buffer.is-view {} + es.array-buffer.slice {} + es.data-view {} + es.date.now {} + es.date.to-iso-string {} + es.date.to-json {} + es.date.to-primitive {} + es.date.to-string {} + es.function.bind {} + es.function.has-instance {} + es.function.name {} + es.global-this {} + es.json.stringify {} + es.json.to-string-tag {} + es.map {} + es.math.acosh {} + es.math.asinh {} + es.math.atanh {} + es.math.cbrt {} + es.math.clz32 {} + es.math.cosh {} + es.math.expm1 {} + es.math.fround {} + es.math.hypot {} + es.math.imul {} + es.math.log10 {} + es.math.log1p {} + es.math.log2 {} + es.math.sign {} + es.math.sinh {} + es.math.tanh {} + es.math.to-string-tag {} + es.math.trunc {} + es.number.constructor {} + es.number.epsilon {} + es.number.is-finite {} + es.number.is-integer {} + es.number.is-nan {} + es.number.is-safe-integer {} + es.number.max-safe-integer {} + es.number.min-safe-integer {} + es.number.parse-float {} + es.number.parse-int {} + es.number.to-fixed {} + es.number.to-precision {} + es.object.assign {} + es.object.create {} + es.object.define-getter {} + es.object.define-properties {} + es.object.define-property {} + es.object.define-setter {} + es.object.entries {} + es.object.freeze {} + es.object.from-entries {} + es.object.get-own-property-descriptor {} + es.object.get-own-property-descriptors {} + es.object.get-own-property-names {} + es.object.get-prototype-of {} + es.object.is {} + es.object.is-extensible {} + es.object.is-frozen {} + es.object.is-sealed {} + es.object.keys {} + es.object.lookup-getter {} + es.object.lookup-setter {} + es.object.prevent-extensions {} + es.object.seal {} + es.object.set-prototype-of {} + es.object.to-string {} + es.object.values {} + es.parse-float {} + es.parse-int {} + es.promise {} + es.promise.all-settled {} + es.promise.finally {} + es.reflect.apply {} + es.reflect.construct {} + es.reflect.define-property {} + es.reflect.delete-property {} + es.reflect.get {} + es.reflect.get-own-property-descriptor {} + es.reflect.get-prototype-of {} + es.reflect.has {} + es.reflect.is-extensible {} + es.reflect.own-keys {} + es.reflect.prevent-extensions {} + es.reflect.set {} + es.reflect.set-prototype-of {} + es.regexp.constructor {} + es.regexp.exec {} + es.regexp.flags {} + es.regexp.sticky {} + es.regexp.test {} + es.regexp.to-string {} + es.set {} + es.string.code-point-at {} + es.string.ends-with {} + es.string.from-code-point {} + es.string.includes {} + es.string.iterator {} + es.string.match {} + es.string.match-all {} + es.string.pad-end {} + es.string.pad-start {} + es.string.raw {} + es.string.repeat {} + es.string.replace {} + es.string.search {} + es.string.split {} + es.string.starts-with {} + es.string.trim {} + es.string.trim-end {} + es.string.trim-start {} + es.string.anchor {} + es.string.big {} + es.string.blink {} + es.string.bold {} + es.string.fixed {} + es.string.fontcolor {} + es.string.fontsize {} + es.string.italics {} + es.string.link {} + es.string.small {} + es.string.strike {} + es.string.sub {} + es.string.sup {} + es.typed-array.float32-array {} + es.typed-array.float64-array {} + es.typed-array.int8-array {} + es.typed-array.int16-array {} + es.typed-array.int32-array {} + es.typed-array.uint8-array {} + es.typed-array.uint8-clamped-array {} + es.typed-array.uint16-array {} + es.typed-array.uint32-array {} + es.typed-array.copy-within {} + es.typed-array.every {} + es.typed-array.fill {} + es.typed-array.filter {} + es.typed-array.find {} + es.typed-array.find-index {} + es.typed-array.for-each {} + es.typed-array.from {} + es.typed-array.includes {} + es.typed-array.index-of {} + es.typed-array.iterator {} + es.typed-array.join {} + es.typed-array.last-index-of {} + es.typed-array.map {} + es.typed-array.of {} + es.typed-array.reduce {} + es.typed-array.reduce-right {} + es.typed-array.reverse {} + es.typed-array.set {} + es.typed-array.slice {} + es.typed-array.some {} + es.typed-array.sort {} + es.typed-array.subarray {} + es.typed-array.to-locale-string {} + es.typed-array.to-string {} + es.weak-map {} + es.weak-set {} + esnext.aggregate-error {} + esnext.array.is-template-object {} + esnext.array.last-index {} + esnext.array.last-item {} + esnext.async-iterator.constructor {} + esnext.async-iterator.as-indexed-pairs {} + esnext.async-iterator.drop {} + esnext.async-iterator.every {} + esnext.async-iterator.filter {} + esnext.async-iterator.find {} + esnext.async-iterator.flat-map {} + esnext.async-iterator.for-each {} + esnext.async-iterator.from {} + esnext.async-iterator.map {} + esnext.async-iterator.reduce {} + esnext.async-iterator.some {} + esnext.async-iterator.take {} + esnext.async-iterator.to-array {} + esnext.composite-key {} + esnext.composite-symbol {} + esnext.global-this {} + esnext.iterator.constructor {} + esnext.iterator.as-indexed-pairs {} + esnext.iterator.drop {} + esnext.iterator.every {} + esnext.iterator.filter {} + esnext.iterator.find {} + esnext.iterator.flat-map {} + esnext.iterator.for-each {} + esnext.iterator.from {} + esnext.iterator.map {} + esnext.iterator.reduce {} + esnext.iterator.some {} + esnext.iterator.take {} + esnext.iterator.to-array {} + esnext.map.delete-all {} + esnext.map.every {} + esnext.map.filter {} + esnext.map.find {} + esnext.map.find-key {} + esnext.map.from {} + esnext.map.group-by {} + esnext.map.includes {} + esnext.map.key-by {} + esnext.map.key-of {} + esnext.map.map-keys {} + esnext.map.map-values {} + esnext.map.merge {} + esnext.map.of {} + esnext.map.reduce {} + esnext.map.some {} + esnext.map.update {} + esnext.map.update-or-insert {} + esnext.map.upsert {} + esnext.math.clamp {} + esnext.math.deg-per-rad {} + esnext.math.degrees {} + esnext.math.fscale {} + esnext.math.iaddh {} + esnext.math.imulh {} + esnext.math.isubh {} + esnext.math.rad-per-deg {} + esnext.math.radians {} + esnext.math.scale {} + esnext.math.seeded-prng {} + esnext.math.signbit {} + esnext.math.umulh {} + esnext.number.from-string {} + esnext.object.iterate-entries {} + esnext.object.iterate-keys {} + esnext.object.iterate-values {} + esnext.observable {} + esnext.promise.all-settled {} + esnext.promise.any {} + esnext.promise.try {} + esnext.reflect.define-metadata {} + esnext.reflect.delete-metadata {} + esnext.reflect.get-metadata {} + esnext.reflect.get-metadata-keys {} + esnext.reflect.get-own-metadata {} + esnext.reflect.get-own-metadata-keys {} + esnext.reflect.has-metadata {} + esnext.reflect.has-own-metadata {} + esnext.reflect.metadata {} + esnext.set.add-all {} + esnext.set.delete-all {} + esnext.set.difference {} + esnext.set.every {} + esnext.set.filter {} + esnext.set.find {} + esnext.set.from {} + esnext.set.intersection {} + esnext.set.is-disjoint-from {} + esnext.set.is-subset-of {} + esnext.set.is-superset-of {} + esnext.set.join {} + esnext.set.map {} + esnext.set.of {} + esnext.set.reduce {} + esnext.set.some {} + esnext.set.symmetric-difference {} + esnext.set.union {} + esnext.string.at {} + esnext.string.code-points {} + esnext.string.match-all {} + esnext.string.replace-all {} + esnext.symbol.async-dispose {} + esnext.symbol.dispose {} + esnext.symbol.observable {} + esnext.symbol.pattern-match {} + esnext.symbol.replace-all {} + esnext.weak-map.delete-all {} + esnext.weak-map.from {} + esnext.weak-map.of {} + esnext.weak-map.upsert {} + esnext.weak-set.add-all {} + esnext.weak-set.delete-all {} + esnext.weak-set.from {} + esnext.weak-set.of {} + web.dom-collections.for-each {} + web.dom-collections.iterator {} web.immediate {} - web.dom.iterable {} + web.queue-microtask {} + web.timers {} + web.url {} + web.url.to-json {} + web.url-search-params {} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/options.json b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/options.json deleted file mode 100644 index 5e37354bd855..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/options.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 55, - "uglify": true - }, - "useBuiltIns": "entry", - "modules": false - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/stderr.txt deleted file mode 100644 index dbee5e8f3eb3..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs-uglify/stderr.txt +++ /dev/null @@ -1,6 +0,0 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. - -You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/input.mjs b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/input.mjs index c3030bdd6280..66bfb4d1516b 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/input.mjs +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/input.mjs @@ -1 +1 @@ -import '@babel/polyfill'; +import 'core-js'; diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stderr.txt index dbee5e8f3eb3..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stdout.txt index 3814bd26e82b..8d43163d36b9 100644 --- a/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stdout.txt +++ b/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/stdout.txt @@ -50,132 +50,323 @@ Using plugins: Using polyfills with `entry` option: -[/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/input.mjs] Replaced @babel/polyfill entries with the following polyfills: - es6.array.copy-within { "ie":"10" } - es6.array.fill { "ie":"10" } - es6.array.find { "ie":"10" } - es6.array.find-index { "ie":"10" } - es7.array.flat-map { "chrome":"54", "ie":"10", "node":"6" } - es6.array.from { "ie":"10", "node":"6" } - es7.array.includes { "ie":"10" } - es6.array.iterator { "ie":"10" } - es6.array.of { "ie":"10" } - es6.array.sort { "chrome":"54", "node":"6" } - es6.array.species { "ie":"10", "node":"6" } - es6.date.to-primitive { "ie":"10" } - es6.function.has-instance { "ie":"10", "node":"6" } - es6.function.name { "ie":"10" } - es6.map { "ie":"10", "node":"6" } - es6.math.acosh { "ie":"10" } - es6.math.asinh { "ie":"10" } - es6.math.atanh { "ie":"10" } - es6.math.cbrt { "ie":"10" } - es6.math.clz32 { "ie":"10" } - es6.math.cosh { "ie":"10" } - es6.math.expm1 { "ie":"10" } - es6.math.fround { "ie":"10" } - es6.math.hypot { "ie":"10" } - es6.math.imul { "ie":"10" } - es6.math.log1p { "ie":"10" } - es6.math.log10 { "ie":"10" } - es6.math.log2 { "ie":"10" } - es6.math.sign { "ie":"10" } - es6.math.sinh { "ie":"10" } - es6.math.tanh { "ie":"10" } - es6.math.trunc { "ie":"10" } - es6.number.constructor { "ie":"10" } - es6.number.epsilon { "ie":"10" } - es6.number.is-finite { "ie":"10" } - es6.number.is-integer { "ie":"10" } - es6.number.is-nan { "ie":"10" } - es6.number.is-safe-integer { "ie":"10" } - es6.number.max-safe-integer { "ie":"10" } - es6.number.min-safe-integer { "ie":"10" } - es6.number.parse-float { "ie":"10" } - es6.number.parse-int { "ie":"10" } - es6.object.assign { "ie":"10" } - es7.object.define-getter { "chrome":"54", "ie":"10", "node":"6" } - es7.object.define-setter { "chrome":"54", "ie":"10", "node":"6" } - es7.object.entries { "ie":"10", "node":"6" } - es6.object.freeze { "ie":"10" } - es6.object.get-own-property-descriptor { "ie":"10" } - es7.object.get-own-property-descriptors { "ie":"10", "node":"6" } - es6.object.get-own-property-names { "ie":"10" } - es6.object.get-prototype-of { "ie":"10" } - es7.object.lookup-getter { "chrome":"54", "ie":"10", "node":"6" } - es7.object.lookup-setter { "chrome":"54", "ie":"10", "node":"6" } - es6.object.prevent-extensions { "ie":"10" } - es6.object.to-string { "chrome":"54", "ie":"10", "node":"6" } - es6.object.is { "ie":"10" } - es6.object.is-frozen { "ie":"10" } - es6.object.is-sealed { "ie":"10" } - es6.object.is-extensible { "ie":"10" } - es6.object.keys { "ie":"10" } - es6.object.seal { "ie":"10" } - es6.object.set-prototype-of { "ie":"10" } - es7.object.values { "ie":"10", "node":"6" } - es6.promise { "ie":"10", "node":"6" } - es7.promise.finally { "chrome":"54", "ie":"10", "node":"6" } - es6.reflect.apply { "ie":"10" } - es6.reflect.construct { "ie":"10" } - es6.reflect.define-property { "ie":"10" } - es6.reflect.delete-property { "ie":"10" } - es6.reflect.get { "ie":"10" } - es6.reflect.get-own-property-descriptor { "ie":"10" } - es6.reflect.get-prototype-of { "ie":"10" } - es6.reflect.has { "ie":"10" } - es6.reflect.is-extensible { "ie":"10" } - es6.reflect.own-keys { "ie":"10" } - es6.reflect.prevent-extensions { "ie":"10" } - es6.reflect.set { "ie":"10" } - es6.reflect.set-prototype-of { "ie":"10" } - es6.regexp.constructor { "ie":"10" } - es6.regexp.flags { "ie":"10" } - es6.regexp.match { "ie":"10" } - es6.regexp.replace { "ie":"10" } - es6.regexp.split { "ie":"10" } - es6.regexp.search { "ie":"10" } - es6.regexp.to-string { "ie":"10" } - es6.set { "ie":"10", "node":"6" } - es6.symbol { "ie":"10", "node":"6" } - es7.symbol.async-iterator { "chrome":"54", "ie":"10", "node":"6" } - es6.string.anchor { "ie":"10" } - es6.string.big { "ie":"10" } - es6.string.blink { "ie":"10" } - es6.string.bold { "ie":"10" } - es6.string.code-point-at { "ie":"10" } - es6.string.ends-with { "ie":"10" } - es6.string.fixed { "ie":"10" } - es6.string.fontcolor { "ie":"10" } - es6.string.fontsize { "ie":"10" } - es6.string.from-code-point { "ie":"10" } - es6.string.includes { "ie":"10" } - es6.string.italics { "ie":"10" } - es6.string.iterator { "ie":"10" } - es6.string.link { "ie":"10" } - es7.string.pad-start { "chrome":"54", "ie":"10", "node":"6" } - es7.string.pad-end { "chrome":"54", "ie":"10", "node":"6" } - es6.string.raw { "ie":"10" } - es6.string.repeat { "ie":"10" } - es6.string.small { "ie":"10" } - es6.string.starts-with { "ie":"10" } - es6.string.strike { "ie":"10" } - es6.string.sub { "ie":"10" } - es6.string.sup { "ie":"10" } - es7.string.trim-left { "chrome":"54", "ie":"10", "node":"6" } - es7.string.trim-right { "chrome":"54", "ie":"10", "node":"6" } - es6.typed.array-buffer { "ie":"10", "node":"6" } - es6.typed.int8-array { "ie":"10", "node":"6" } - es6.typed.uint8-array { "ie":"10", "node":"6" } - es6.typed.uint8-clamped-array { "ie":"10", "node":"6" } - es6.typed.int16-array { "ie":"10", "node":"6" } - es6.typed.uint16-array { "ie":"10", "node":"6" } - es6.typed.int32-array { "ie":"10", "node":"6" } - es6.typed.uint32-array { "ie":"10", "node":"6" } - es6.typed.float32-array { "ie":"10", "node":"6" } - es6.typed.float64-array { "ie":"10", "node":"6" } - es6.weak-map { "ie":"10", "node":"6" } - es6.weak-set { "ie":"10", "node":"6" } - web.timers { "chrome":"54", "ie":"10", "node":"6" } - web.immediate { "chrome":"54", "ie":"10", "node":"6" } - web.dom.iterable { "chrome":"54", "ie":"10", "node":"6" } +[/packages/babel-preset-env/test/fixtures/debug/entry-no-corejs/input.mjs] Replaced core-js entries with the following polyfills: + es.symbol { "ie":"10" } + es.symbol.description { "chrome":"54", "ie":"10", "node":"6" } + es.symbol.async-iterator { "chrome":"54", "ie":"10", "node":"6" } + es.symbol.has-instance { "ie":"10" } + es.symbol.is-concat-spreadable { "ie":"10" } + es.symbol.iterator { "ie":"10" } + es.symbol.match { "ie":"10" } + es.symbol.match-all { "chrome":"54", "ie":"10", "node":"6" } + es.symbol.replace { "ie":"10" } + es.symbol.search { "ie":"10" } + es.symbol.species { "ie":"10", "node":"6" } + es.symbol.split { "ie":"10" } + es.symbol.to-primitive { "ie":"10" } + es.symbol.to-string-tag { "ie":"10" } + es.symbol.unscopables { "ie":"10" } + es.array.concat { "ie":"10", "node":"6" } + es.array.copy-within { "ie":"10" } + es.array.every { "ie":"10" } + es.array.fill { "ie":"10" } + es.array.filter { "ie":"10", "node":"6" } + es.array.find { "ie":"10" } + es.array.find-index { "ie":"10" } + es.array.flat { "chrome":"54", "ie":"10", "node":"6" } + es.array.flat-map { "chrome":"54", "ie":"10", "node":"6" } + es.array.for-each { "ie":"10" } + es.array.from { "ie":"10", "node":"6" } + es.array.includes { "ie":"10", "node":"6" } + es.array.index-of { "ie":"10", "node":"6" } + es.array.iterator { "chrome":"54", "ie":"10", "node":"6" } + es.array.join { "ie":"10" } + es.array.last-index-of { "ie":"10", "node":"6" } + es.array.map { "ie":"10", "node":"6" } + es.array.of { "ie":"10" } + es.array.reduce { "ie":"10" } + es.array.reduce-right { "ie":"10" } + es.array.slice { "ie":"10", "node":"6" } + es.array.some { "ie":"10" } + es.array.sort { "chrome":"54", "node":"6" } + es.array.species { "ie":"10", "node":"6" } + es.array.splice { "ie":"10", "node":"6" } + es.array.unscopables.flat { "chrome":"54", "ie":"10", "node":"6" } + es.array.unscopables.flat-map { "chrome":"54", "ie":"10", "node":"6" } + es.array-buffer.constructor { "ie":"10" } + es.array-buffer.is-view { "ie":"10" } + es.array-buffer.slice { "ie":"10" } + es.date.to-primitive { "ie":"10" } + es.function.has-instance { "ie":"10", "node":"6" } + es.function.name { "ie":"10" } + es.global-this { "chrome":"54", "ie":"10", "node":"6" } + es.json.stringify { "chrome":"54", "ie":"10", "node":"6" } + es.json.to-string-tag { "ie":"10" } + es.map { "ie":"10", "node":"6" } + es.math.acosh { "ie":"10", "node":"6" } + es.math.asinh { "ie":"10" } + es.math.atanh { "ie":"10" } + es.math.cbrt { "ie":"10" } + es.math.clz32 { "ie":"10" } + es.math.cosh { "ie":"10" } + es.math.expm1 { "ie":"10" } + es.math.fround { "ie":"10" } + es.math.hypot { "chrome":"54", "ie":"10", "node":"6" } + es.math.imul { "ie":"10" } + es.math.log10 { "ie":"10" } + es.math.log1p { "ie":"10" } + es.math.log2 { "ie":"10" } + es.math.sign { "ie":"10" } + es.math.sinh { "ie":"10" } + es.math.tanh { "ie":"10" } + es.math.to-string-tag { "ie":"10" } + es.math.trunc { "ie":"10" } + es.number.constructor { "ie":"10" } + es.number.epsilon { "ie":"10" } + es.number.is-finite { "ie":"10" } + es.number.is-integer { "ie":"10" } + es.number.is-nan { "ie":"10" } + es.number.is-safe-integer { "ie":"10" } + es.number.max-safe-integer { "ie":"10" } + es.number.min-safe-integer { "ie":"10" } + es.number.parse-float { "ie":"10" } + es.number.parse-int { "ie":"10" } + es.number.to-fixed { "ie":"10" } + es.object.assign { "ie":"10" } + es.object.define-getter { "chrome":"54", "ie":"10", "node":"6" } + es.object.define-setter { "chrome":"54", "ie":"10", "node":"6" } + es.object.entries { "ie":"10", "node":"6" } + es.object.freeze { "ie":"10" } + es.object.from-entries { "chrome":"54", "ie":"10", "node":"6" } + es.object.get-own-property-descriptor { "ie":"10" } + es.object.get-own-property-descriptors { "ie":"10", "node":"6" } + es.object.get-own-property-names { "ie":"10" } + es.object.get-prototype-of { "ie":"10" } + es.object.is { "ie":"10" } + es.object.is-extensible { "ie":"10" } + es.object.is-frozen { "ie":"10" } + es.object.is-sealed { "ie":"10" } + es.object.keys { "ie":"10" } + es.object.lookup-getter { "chrome":"54", "ie":"10", "node":"6" } + es.object.lookup-setter { "chrome":"54", "ie":"10", "node":"6" } + es.object.prevent-extensions { "ie":"10" } + es.object.seal { "ie":"10" } + es.object.set-prototype-of { "ie":"10" } + es.object.to-string { "ie":"10" } + es.object.values { "ie":"10", "node":"6" } + es.promise { "chrome":"54", "ie":"10", "node":"6" } + es.promise.all-settled { "chrome":"54", "ie":"10", "node":"6" } + es.promise.finally { "chrome":"54", "ie":"10", "node":"6" } + es.reflect.apply { "ie":"10" } + es.reflect.construct { "ie":"10" } + es.reflect.define-property { "ie":"10" } + es.reflect.delete-property { "ie":"10" } + es.reflect.get { "ie":"10" } + es.reflect.get-own-property-descriptor { "ie":"10" } + es.reflect.get-prototype-of { "ie":"10" } + es.reflect.has { "ie":"10" } + es.reflect.is-extensible { "ie":"10" } + es.reflect.own-keys { "ie":"10" } + es.reflect.prevent-extensions { "ie":"10" } + es.reflect.set { "ie":"10" } + es.reflect.set-prototype-of { "ie":"10" } + es.regexp.constructor { "ie":"10", "node":"6" } + es.regexp.exec { "ie":"10" } + es.regexp.flags { "ie":"10" } + es.regexp.sticky { "ie":"10" } + es.regexp.test { "ie":"10", "node":"6" } + es.regexp.to-string { "ie":"10" } + es.set { "ie":"10", "node":"6" } + es.string.code-point-at { "ie":"10" } + es.string.ends-with { "ie":"10", "node":"6" } + es.string.from-code-point { "ie":"10" } + es.string.includes { "ie":"10", "node":"6" } + es.string.iterator { "ie":"10" } + es.string.match { "ie":"10", "node":"6" } + es.string.match-all { "chrome":"54", "ie":"10", "node":"6" } + es.string.pad-end { "chrome":"54", "ie":"10", "node":"6" } + es.string.pad-start { "chrome":"54", "ie":"10", "node":"6" } + es.string.raw { "ie":"10" } + es.string.repeat { "ie":"10" } + es.string.replace { "chrome":"54", "ie":"10", "node":"6" } + es.string.search { "ie":"10", "node":"6" } + es.string.split { "ie":"10", "node":"6" } + es.string.starts-with { "ie":"10", "node":"6" } + es.string.trim { "chrome":"54", "ie":"10", "node":"6" } + es.string.trim-end { "chrome":"54", "ie":"10", "node":"6" } + es.string.trim-start { "chrome":"54", "ie":"10", "node":"6" } + es.string.anchor { "ie":"10" } + es.string.big { "ie":"10" } + es.string.blink { "ie":"10" } + es.string.bold { "ie":"10" } + es.string.fixed { "ie":"10" } + es.string.fontcolor { "ie":"10" } + es.string.fontsize { "ie":"10" } + es.string.italics { "ie":"10" } + es.string.link { "ie":"10" } + es.string.small { "ie":"10" } + es.string.strike { "ie":"10" } + es.string.sub { "ie":"10" } + es.string.sup { "ie":"10" } + es.typed-array.float32-array { "ie":"10", "node":"6" } + es.typed-array.float64-array { "ie":"10", "node":"6" } + es.typed-array.int8-array { "ie":"10", "node":"6" } + es.typed-array.int16-array { "ie":"10", "node":"6" } + es.typed-array.int32-array { "ie":"10", "node":"6" } + es.typed-array.uint8-array { "ie":"10", "node":"6" } + es.typed-array.uint8-clamped-array { "ie":"10", "node":"6" } + es.typed-array.uint16-array { "ie":"10", "node":"6" } + es.typed-array.uint32-array { "ie":"10", "node":"6" } + es.typed-array.copy-within { "ie":"10" } + es.typed-array.every { "ie":"10" } + es.typed-array.fill { "ie":"10" } + es.typed-array.filter { "ie":"10" } + es.typed-array.find { "ie":"10" } + es.typed-array.find-index { "ie":"10" } + es.typed-array.for-each { "ie":"10" } + es.typed-array.from { "ie":"10", "node":"6" } + es.typed-array.includes { "ie":"10" } + es.typed-array.index-of { "ie":"10" } + es.typed-array.iterator { "ie":"10" } + es.typed-array.join { "ie":"10" } + es.typed-array.last-index-of { "ie":"10" } + es.typed-array.map { "ie":"10" } + es.typed-array.of { "ie":"10", "node":"6" } + es.typed-array.reduce { "ie":"10" } + es.typed-array.reduce-right { "ie":"10" } + es.typed-array.reverse { "ie":"10" } + es.typed-array.set { "ie":"10" } + es.typed-array.slice { "ie":"10" } + es.typed-array.some { "ie":"10" } + es.typed-array.sort { "ie":"10" } + es.typed-array.subarray { "ie":"10" } + es.typed-array.to-locale-string { "ie":"10" } + es.typed-array.to-string { "ie":"10", "node":"6" } + es.weak-map { "ie":"10", "node":"6" } + es.weak-set { "ie":"10", "node":"6" } + esnext.aggregate-error { "chrome":"54", "ie":"10", "node":"6" } + esnext.array.is-template-object { "chrome":"54", "ie":"10", "node":"6" } + esnext.array.last-index { "chrome":"54", "ie":"10", "node":"6" } + esnext.array.last-item { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.constructor { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.as-indexed-pairs { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.drop { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.every { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.filter { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.find { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.flat-map { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.for-each { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.from { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.map { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.reduce { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.some { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.take { "chrome":"54", "ie":"10", "node":"6" } + esnext.async-iterator.to-array { "chrome":"54", "ie":"10", "node":"6" } + esnext.composite-key { "chrome":"54", "ie":"10", "node":"6" } + esnext.composite-symbol { "chrome":"54", "ie":"10", "node":"6" } + esnext.global-this { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.constructor { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.as-indexed-pairs { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.drop { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.every { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.filter { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.find { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.flat-map { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.for-each { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.from { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.map { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.reduce { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.some { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.take { "chrome":"54", "ie":"10", "node":"6" } + esnext.iterator.to-array { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.delete-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.every { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.filter { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.find { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.find-key { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.from { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.group-by { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.includes { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.key-by { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.key-of { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.map-keys { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.map-values { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.merge { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.of { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.reduce { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.some { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.update { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.update-or-insert { "chrome":"54", "ie":"10", "node":"6" } + esnext.map.upsert { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.clamp { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.deg-per-rad { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.degrees { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.fscale { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.iaddh { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.imulh { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.isubh { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.rad-per-deg { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.radians { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.scale { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.seeded-prng { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.signbit { "chrome":"54", "ie":"10", "node":"6" } + esnext.math.umulh { "chrome":"54", "ie":"10", "node":"6" } + esnext.number.from-string { "chrome":"54", "ie":"10", "node":"6" } + esnext.object.iterate-entries { "chrome":"54", "ie":"10", "node":"6" } + esnext.object.iterate-keys { "chrome":"54", "ie":"10", "node":"6" } + esnext.object.iterate-values { "chrome":"54", "ie":"10", "node":"6" } + esnext.observable { "chrome":"54", "ie":"10", "node":"6" } + esnext.promise.all-settled { "chrome":"54", "ie":"10", "node":"6" } + esnext.promise.any { "chrome":"54", "ie":"10", "node":"6" } + esnext.promise.try { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.define-metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.delete-metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.get-metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.get-metadata-keys { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.get-own-metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.get-own-metadata-keys { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.has-metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.has-own-metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.reflect.metadata { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.add-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.delete-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.difference { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.every { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.filter { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.find { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.from { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.intersection { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.is-disjoint-from { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.is-subset-of { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.is-superset-of { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.join { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.map { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.of { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.reduce { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.some { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.symmetric-difference { "chrome":"54", "ie":"10", "node":"6" } + esnext.set.union { "chrome":"54", "ie":"10", "node":"6" } + esnext.string.at { "chrome":"54", "ie":"10", "node":"6" } + esnext.string.code-points { "chrome":"54", "ie":"10", "node":"6" } + esnext.string.match-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.string.replace-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.symbol.async-dispose { "chrome":"54", "ie":"10", "node":"6" } + esnext.symbol.dispose { "chrome":"54", "ie":"10", "node":"6" } + esnext.symbol.observable { "chrome":"54", "ie":"10", "node":"6" } + esnext.symbol.pattern-match { "chrome":"54", "ie":"10", "node":"6" } + esnext.symbol.replace-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-map.delete-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-map.from { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-map.of { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-map.upsert { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-set.add-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-set.delete-all { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-set.from { "chrome":"54", "ie":"10", "node":"6" } + esnext.weak-set.of { "chrome":"54", "ie":"10", "node":"6" } + web.dom-collections.for-each { "chrome":"54", "ie":"10" } + web.dom-collections.iterator { "chrome":"54", "ie":"10" } + web.immediate { "chrome":"54" } + web.queue-microtask { "chrome":"54", "ie":"10", "node":"6" } + web.url { "chrome":"54", "ie":"10", "node":"6" } + web.url.to-json { "chrome":"54", "ie":"10", "node":"6" } + web.url-search-params { "chrome":"54", "ie":"10", "node":"6" } diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-1/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-1/input.js deleted file mode 100644 index 6113c3b69b28..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-1/input.js +++ /dev/null @@ -1,7 +0,0 @@ -const foo = new Promise((resolve) => { - resolve(new Map()); -}); - -queueMicrotask(() => globalThis); - -Observable.from(10); diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-1/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-1/options.json deleted file mode 100644 index bc84c3a017cd..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-1/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-2/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-2/input.js deleted file mode 100644 index 4915d62092eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-2/input.js +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-2/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-2/options.json deleted file mode 100644 index bc84c3a017cd..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-2/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-1/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-1/input.js deleted file mode 100644 index 6113c3b69b28..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-1/input.js +++ /dev/null @@ -1,7 +0,0 @@ -const foo = new Promise((resolve) => { - resolve(new Map()); -}); - -queueMicrotask(() => globalThis); - -Observable.from(10); diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-1/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-1/options.json deleted file mode 100644 index d028d3be910f..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-1/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 71 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-2/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-2/input.js deleted file mode 100644 index 4915d62092eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-2/input.js +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-2/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-2/options.json deleted file mode 100644 index d028d3be910f..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-chrome-71-2/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 71 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-1/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-1/input.js deleted file mode 100644 index 4ec1fa479e22..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-1/input.js +++ /dev/null @@ -1 +0,0 @@ -var foo = "bar"; diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-1/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-1/options.json deleted file mode 100644 index bc84c3a017cd..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-1/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-2/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-2/input.js deleted file mode 100644 index 3fbea9d21153..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-2/input.js +++ /dev/null @@ -1,5 +0,0 @@ -var x = 0; - -for (var i = 0; i < 5; i++) { - x += i; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-2/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-2/options.json deleted file mode 100644 index bc84c3a017cd..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-none-2/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-1/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-1/input.js deleted file mode 100644 index 6113c3b69b28..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-1/input.js +++ /dev/null @@ -1,7 +0,0 @@ -const foo = new Promise((resolve) => { - resolve(new Map()); -}); - -queueMicrotask(() => globalThis); - -Observable.from(10); diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-1/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-1/options.json deleted file mode 100644 index 17e594c8c6f1..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-1/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "useBuiltIns": "usage", - "corejs": { "version": 2, "proposals": true } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-2/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-2/input.js deleted file mode 100644 index 4915d62092eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-2/input.js +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-2/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-2/options.json deleted file mode 100644 index 17e594c8c6f1..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-2/options.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "useBuiltIns": "usage", - "corejs": { "version": 2, "proposals": true } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-1/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-1/input.js deleted file mode 100644 index 6113c3b69b28..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-1/input.js +++ /dev/null @@ -1,7 +0,0 @@ -const foo = new Promise((resolve) => { - resolve(new Map()); -}); - -queueMicrotask(() => globalThis); - -Observable.from(10); diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-1/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-1/options.json deleted file mode 100644 index 7239e5721426..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-1/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 71 - }, - "useBuiltIns": "usage", - "corejs": { "version": 2, "proposals": true } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-2/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-2/input.js deleted file mode 100644 index 4915d62092eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-2/input.js +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-2/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-2/options.json deleted file mode 100644 index 7239e5721426..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-proposals-chrome-71-2/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 71 - }, - "useBuiltIns": "usage", - "corejs": { "version": 2, "proposals": true } - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-1/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-1/input.js deleted file mode 100644 index 6113c3b69b28..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-1/input.js +++ /dev/null @@ -1,7 +0,0 @@ -const foo = new Promise((resolve) => { - resolve(new Map()); -}); - -queueMicrotask(() => globalThis); - -Observable.from(10); diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-1/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-1/options.json deleted file mode 100644 index 9069c3b78807..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-1/options.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "shippedProposals": true, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-2/input.js b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-2/input.js deleted file mode 100644 index 4915d62092eb..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-2/input.js +++ /dev/null @@ -1,3 +0,0 @@ -function* a() { - yield* 1; -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-2/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-2/options.json deleted file mode 100644 index 9069c3b78807..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-shippedProposals-2/options.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 52, - "firefox": 50, - "ie": 11 - }, - "shippedProposals": true, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/input.mjs b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/input.mjs deleted file mode 100644 index c3030bdd6280..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import '@babel/polyfill'; diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/options.json b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/options.json deleted file mode 100644 index c1118296ce3a..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/options.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "validateLogs": true, - "ignoreOutput": true, - "presets": [ - [ - "env", - { - "debug": true, - "targets": { - "chrome": 55 - }, - "useBuiltIns": "usage", - "corejs": 2 - } - ] - ] -} diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/stderr.txt deleted file mode 100644 index 72ca7e1a1f99..000000000000 --- a/packages/babel-preset-env/test/fixtures/debug/usage-corejs2-with-import/stderr.txt +++ /dev/null @@ -1,2 +0,0 @@ -When setting `useBuiltIns: 'usage'`, polyfills are automatically imported when needed. - Please remove the `import '@babel/polyfill'` call or use `useBuiltIns: 'entry'` instead. \ No newline at end of file diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stderr.txt index dbee5e8f3eb3..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stdout.txt index 19a2eaf39c0c..6b028e65a408 100644 --- a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stdout.txt +++ b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/stdout.txt @@ -50,9 +50,11 @@ Using plugins: Using polyfills with `usage` option: [/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-1/input.js] Added following core-js polyfills: - es6.object.to-string { "chrome":"52", "firefox":"50", "ie":"11" } - es6.promise { "ie":"11" } - es6.map { "firefox":"50", "ie":"11" } - es6.string.iterator { "ie":"11" } - es6.array.iterator { "ie":"11" } - web.dom.iterable { "chrome":"52", "firefox":"50", "ie":"11" } + es.array.iterator { "chrome":"52", "firefox":"50", "ie":"11" } + es.global-this { "chrome":"52", "firefox":"50", "ie":"11" } + es.map { "firefox":"50", "ie":"11" } + es.object.to-string { "firefox":"50", "ie":"11" } + es.promise { "chrome":"52", "firefox":"50", "ie":"11" } + es.string.iterator { "ie":"11" } + web.dom-collections.iterator { "chrome":"52", "firefox":"50", "ie":"11" } + web.queue-microtask { "chrome":"52", "firefox":"50", "ie":"11" } diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stderr.txt index d9061acb2c57..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stdout.txt b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stdout.txt index 58679fde4d8d..2ad812f17603 100644 --- a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stdout.txt +++ b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/stdout.txt @@ -49,7 +49,9 @@ Using plugins: Using polyfills with `usage` option: -[/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/input.js] Added following core-js polyfill: - web.dom.iterable { "chrome":"52", "firefox":"50", "ie":"11" } +[/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/input.js] Added following core-js polyfills: + es.array.iterator { "chrome":"52", "firefox":"50", "ie":"11" } + es.string.iterator { "ie":"11" } + web.dom-collections.iterator { "chrome":"52", "firefox":"50", "ie":"11" } [/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-2/input.js] Based on your code and targets, added regenerator-runtime. diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-1/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-1/stderr.txt index dbee5e8f3eb3..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-1/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-1/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-2/stderr.txt b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-2/stderr.txt index dbee5e8f3eb3..026305fd6292 100644 --- a/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-2/stderr.txt +++ b/packages/babel-preset-env/test/fixtures/debug/usage-no-corejs-none-2/stderr.txt @@ -1,6 +1,6 @@ -WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version 2.x when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. +WARNING: We noticed you're using the `useBuiltIns` option without declaring a core-js version. Currently, we assume version `3.6` when no version is passed. Since this default version will likely change in future versions of Babel, we recommend explicitly setting the core-js version you are using via the `corejs` option. You should also be sure that the version you pass to the `corejs` option matches the version specified in your `package.json`'s `dependencies` section. If it doesn't, you need to run one of the following commands: - npm install --save core-js@2 npm install --save core-js@3 - yarn add core-js@2 yarn add core-js@3 \ No newline at end of file + npm install --save core-js@3.6 + yarn add core-js@3.6 diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/input.mjs b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/input.mjs deleted file mode 100644 index bd6332b8bac3..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/input.mjs +++ /dev/null @@ -1 +0,0 @@ -import "core-js"; \ No newline at end of file diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/options.json b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/options.json deleted file mode 100644 index 786316f22efb..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/options.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "presets": [ - [ - "env", - { - "useBuiltIns": "entry", - "corejs": 2, - "modules": false, - "targets": { "chrome": 65 } - } - ] - ], - "plugins": ["./plugin.js"] -} diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/output.mjs b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/output.mjs deleted file mode 100644 index 05407cabf92a..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/output.mjs +++ /dev/null @@ -1,6 +0,0 @@ -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/plugin.js b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/plugin.js deleted file mode 100644 index 931322f3b71d..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-entry/plugin.js +++ /dev/null @@ -1,8 +0,0 @@ -module.exports = () => ({ - visitor: { - ImportDeclaration(path) { - if (path.node.source.value === "core-js") return; - path.node.source.value = "MODIFIED"; - }, - }, -}); diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/input.mjs b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/input.mjs deleted file mode 100644 index b24e09f0c2fd..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/input.mjs +++ /dev/null @@ -1 +0,0 @@ -new Map(); \ No newline at end of file diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/options.json b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/options.json deleted file mode 100644 index d7ce4a4a7218..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/options.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "presets": [ - ["env", { "useBuiltIns": "usage", "corejs": 2, "modules": false }] - ], - "plugins": ["./plugin.js"] -} diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/output.mjs b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/output.mjs deleted file mode 100644 index 2e074eea8b62..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/output.mjs +++ /dev/null @@ -1,6 +0,0 @@ -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; -import "MODIFIED"; -new Map(); diff --git a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/plugin.js b/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/plugin.js deleted file mode 100644 index ddfe181cf61e..000000000000 --- a/packages/babel-preset-env/test/fixtures/sanity/issue-10142-corejs2-usage/plugin.js +++ /dev/null @@ -1,7 +0,0 @@ -module.exports = () => ({ - visitor: { - ImportDeclaration(path) { - path.node.source.value = "MODIFIED"; - }, - }, -}); diff --git a/packages/babel-preset-env/test/get-platform-specific-default.spec.js b/packages/babel-preset-env/test/get-platform-specific-default.spec.js deleted file mode 100644 index 1958a7fa6d0e..000000000000 --- a/packages/babel-preset-env/test/get-platform-specific-default.spec.js +++ /dev/null @@ -1,31 +0,0 @@ -"use strict"; - -const getCoreJS2PlatformSpecificDefaultFor = require("../lib/polyfills/corejs2/get-platform-specific-default") - .default; - -describe("defaults", () => { - describe("getCoreJS2PlatformSpecificDefaultFor", () => { - it("should return web polyfills for non-`node` platform", () => { - const defaultWebIncludesForChromeAndNode = getCoreJS2PlatformSpecificDefaultFor( - { - chrome: "63", - node: "8", - }, - ); - expect(defaultWebIncludesForChromeAndNode).toEqual([ - "web.timers", - "web.immediate", - "web.dom.iterable", - ]); - }); - - it("shouldn't return web polyfills for node platform", () => { - const defaultWebIncludesForChromeAndNode = getCoreJS2PlatformSpecificDefaultFor( - { - node: "8", - }, - ); - expect(defaultWebIncludesForChromeAndNode).toBeNull(); - }); - }); -}); diff --git a/packages/babel-preset-env/test/index.spec.js b/packages/babel-preset-env/test/index.spec.js index 291bb26c71e5..a1d454608385 100644 --- a/packages/babel-preset-env/test/index.spec.js +++ b/packages/babel-preset-env/test/index.spec.js @@ -1,14 +1,10 @@ "use strict"; const babelPresetEnv = require("../lib/index"); -const addCoreJS2UsagePlugin = require("../lib/polyfills/corejs2/usage-plugin") - .default; const addCoreJS3UsagePlugin = require("../lib/polyfills/corejs3/usage-plugin") .default; const addRegeneratorUsagePlugin = require("../lib/polyfills/regenerator/usage-plugin") .default; -const replaceCoreJS2EntryPlugin = require("../lib/polyfills/corejs2/entry-plugin") - .default; const replaceCoreJS3EntryPlugin = require("../lib/polyfills/corejs3/entry-plugin") .default; const removeRegeneratorEntryPlugin = require("../lib/polyfills/regenerator/entry-plugin") @@ -166,22 +162,6 @@ describe("babel-preset-env", () => { }); }); describe("useBuiltIns is set to usage", () => { - describe("using corejs 2", () => { - it("returns an array with core js 2 usage plugin", () => { - const polyfillPlugins = babelPresetEnv.getPolyfillPlugins( - Object.assign( - { - useBuiltIns: "usage", - corejs: { major: 2 }, - regenerator: false, - }, - staticProps, - ), - ); - expect(polyfillPlugins.length).toBe(1); - expect(polyfillPlugins[0][0]).toEqual(addCoreJS2UsagePlugin); - }); - }); describe("using corejs 3", () => { describe("regenerator is set to false", () => { it("returns an array with core js 3 usage plugin", () => { @@ -220,22 +200,6 @@ describe("babel-preset-env", () => { }); }); describe("useBuiltIns is set to entry", () => { - describe("using corejs 2", () => { - it("returns an array with core js 2 entry plugin", () => { - const polyfillPlugins = babelPresetEnv.getPolyfillPlugins( - Object.assign( - { - useBuiltIns: "entry", - corejs: { major: 2 }, - regenerator: true, - }, - staticProps, - ), - ); - expect(polyfillPlugins.length).toBe(1); - expect(polyfillPlugins[0][0]).toEqual(replaceCoreJS2EntryPlugin); - }); - }); describe("using corejs 3", () => { describe("regenerator is set to true", () => { it("returns an array with core js 3 entry plugin", () => { diff --git a/packages/babel-preset-env/test/normalize-options.spec.js b/packages/babel-preset-env/test/normalize-options.spec.js index 948c107cee70..81c446b65c1c 100644 --- a/packages/babel-preset-env/test/normalize-options.spec.js +++ b/packages/babel-preset-env/test/normalize-options.spec.js @@ -66,7 +66,7 @@ describe("normalize-options", () => { ); it("should not throw if corejs version is valid", () => { - [2, 2.1, 3, 3.5].forEach(corejs => { + [3, 3.5].forEach(corejs => { ["entry", "usage"].forEach(useBuiltIns => { expect(() => normalizeOptions.default({ useBuiltIns, corejs }), @@ -85,6 +85,18 @@ describe("normalize-options", () => { }); }); + it("should throw removed option if corejs version is 2", () => { + [2, 2.1].forEach(corejs => { + ["entry", "usage"].forEach(useBuiltIns => { + expect(() => normalizeOptions.default({ useBuiltIns, corejs })) + .toThrowError(`Since Babel 8, the core-js@2 support has been dropped. Please use \`corejs: "3.6"\`. +- If you really want to use obsolete core-js@2, please install \`babel-plugin-polyfill-corejs2\` and add to the "plugins" config + npm install --save-dev babel-plugin-polyfill-corejs2 + yarn add --dev babel-plugin-polyfill-corejs2`); + }); + }); + }); + it("throws when including module plugins", () => { expect(() => normalizeOptions.default({ include: ["proposal-dynamic-import"] }), diff --git a/packages/babel-preset-flow/src/index.js b/packages/babel-preset-flow/src/index.js index da02e7e6c026..fa30fbea9c76 100644 --- a/packages/babel-preset-flow/src/index.js +++ b/packages/babel-preset-flow/src/index.js @@ -1,10 +1,23 @@ import { declare } from "@babel/helper-plugin-utils"; import transformFlowStripTypes from "@babel/plugin-transform-flow-strip-types"; -export default declare((api, { all, allowDeclareFields }) => { - api.assertVersion(7); +export default declare( + (api, { all, allowDeclareFields, ignoreExtensions = false }) => { + api.assertVersion(7); - return { - plugins: [[transformFlowStripTypes, { all, allowDeclareFields }]], - }; -}); + const flowPlugin = [transformFlowStripTypes, { all, allowDeclareFields }]; + + if (ignoreExtensions) { + return { plugins: [flowPlugin] }; + } + + return { + overrides: [ + { + test: filename => filename == null || !/\.tsx?$/.test(filename), + plugins: [flowPlugin], + }, + ], + }; + }, +); diff --git a/packages/babel-preset-react/src/index.js b/packages/babel-preset-react/src/index.js index c57cc52ff580..1ef1cddbae08 100644 --- a/packages/babel-preset-react/src/index.js +++ b/packages/babel-preset-react/src/index.js @@ -9,25 +9,38 @@ import transformReactPure from "@babel/plugin-transform-react-pure-annotations"; export default declare((api, opts) => { api.assertVersion(7); - let { pragma, pragmaFrag } = opts; - const { pure, + pragma, + pragmaFrag, throwIfNamespace = true, - useSpread, - runtime = "classic", + runtime = "automatic", importSource, } = opts; - // TODO: (Babel 8) Remove setting these defaults - if (runtime === "classic") { - pragma = pragma || "React.createElement"; - pragmaFrag = pragmaFrag || "React.Fragment"; - } - // TODO: (Babel 8) Don't cast these options but validate it const development = !!opts.development; - const useBuiltIns = !!opts.useBuiltIns; + + if ("useSpread" in opts) { + throw new Error( + '@babel/preset-react: Since Babel 8, an inline object with spread elements is always used, and the "useSpread" option is no longer available. Please remove it from your config.', + ); + } + + if ("useBuiltIns" in opts) { + const useBuiltInsFormatted = JSON.stringify(opts.useBuiltIns); + throw new Error( + `@babel/preset-react: Since "useBuiltIns" is removed in Babel 8, you can remove it from the config. +- Babel 8 now transforms JSX spread to object spread. If you need to transpile object spread with +\`useBuiltIns: ${useBuiltInsFormatted}\`, you can use the following config +{ + "plugins": [ + ["@babel/plugin-proposal-object-rest-spread", { "loose": true, "useBuiltIns": ${useBuiltInsFormatted} }] + ], + "presets": ["@babel/preset-react"] +}`, + ); + } if (typeof development !== "boolean") { throw new Error( @@ -50,8 +63,6 @@ export default declare((api, opts) => { pragmaFrag, runtime, throwIfNamespace, - useBuiltIns, - useSpread, pure, }, ], diff --git a/packages/babel-preset-react/test/fixtures/preset-options/development-windows/options.json b/packages/babel-preset-react/test/fixtures/preset-options/development-windows/options.json index 6ca8659a61e3..cb9c32c34e68 100644 --- a/packages/babel-preset-react/test/fixtures/preset-options/development-windows/options.json +++ b/packages/babel-preset-react/test/fixtures/preset-options/development-windows/options.json @@ -1,4 +1,4 @@ { - "presets": [["react", { "development": true }]], + "presets": [["react", { "development": true, "runtime": "classic" }]], "os": ["win32"] } diff --git a/packages/babel-preset-react/test/fixtures/preset-options/development/options.json b/packages/babel-preset-react/test/fixtures/preset-options/development/options.json index 69900e734466..d563df88c2a0 100644 --- a/packages/babel-preset-react/test/fixtures/preset-options/development/options.json +++ b/packages/babel-preset-react/test/fixtures/preset-options/development/options.json @@ -1,4 +1,4 @@ { - "presets": [["react", { "development": true }]], + "presets": [["react", { "development": true, "runtime": "classic" }]], "os": ["linux", "darwin"] } diff --git a/packages/babel-preset-react/test/fixtures/preset-options/empty-options/output.js b/packages/babel-preset-react/test/fixtures/preset-options/empty-options/output.js index 6bb6d5f16940..1b9e086df135 100644 --- a/packages/babel-preset-react/test/fixtures/preset-options/empty-options/output.js +++ b/packages/babel-preset-react/test/fixtures/preset-options/empty-options/output.js @@ -1,4 +1,6 @@ +var _reactJsxRuntime = require("react/jsx-runtime"); + /*#__PURE__*/ -React.createElement(Foo, { +_reactJsxRuntime.jsx(Foo, { bar: "baz" }); diff --git a/packages/babel-preset-react/test/fixtures/preset-options/no-options/options.json b/packages/babel-preset-react/test/fixtures/preset-options/no-options/options.json index 12d195e58bc0..d3153f41ed88 100644 --- a/packages/babel-preset-react/test/fixtures/preset-options/no-options/options.json +++ b/packages/babel-preset-react/test/fixtures/preset-options/no-options/options.json @@ -1,3 +1,5 @@ { - "presets": ["react"] + "presets": [ + ["react", { "runtime": "classic" }] + ] } diff --git a/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/options.json b/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/options.json index 12d195e58bc0..f09b6fdf4b3c 100644 --- a/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/options.json +++ b/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/options.json @@ -1,3 +1,6 @@ { - "presets": ["react"] + "presets": [ + ["react", { "runtime": "classic" }] + ], + "throws": "transform-react-jsx: pragma has been set but pragmaFrag has not been set" } diff --git a/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/output.js b/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/output.js deleted file mode 100644 index bc6f729c4978..000000000000 --- a/packages/babel-preset-react/test/fixtures/preset-options/runtime-classic-pragma-no-frag/output.js +++ /dev/null @@ -1,2 +0,0 @@ -/** @jsx jsx */ -const Foo = jsx(React.Fragment, null); diff --git a/packages/babel-preset-react/test/fixtures/regression/11294/options.json b/packages/babel-preset-react/test/fixtures/regression/11294/options.json index 238981a96b81..7362dbe7e4bb 100644 --- a/packages/babel-preset-react/test/fixtures/regression/11294/options.json +++ b/packages/babel-preset-react/test/fixtures/regression/11294/options.json @@ -1,4 +1,4 @@ { "presets": [ - ["react", { "pragma": "__jsx" }]] + ["react", { "pragma": "__jsx", "runtime": "classic" }]] } diff --git a/packages/babel-preset-typescript/package.json b/packages/babel-preset-typescript/package.json index 0f793444e428..1549fca273b7 100644 --- a/packages/babel-preset-typescript/package.json +++ b/packages/babel-preset-typescript/package.json @@ -18,6 +18,7 @@ ], "dependencies": { "@babel/helper-plugin-utils": "workspace:^7.10.4", + "@babel/plugin-syntax-jsx": "workspace:^7.10.4", "@babel/plugin-transform-typescript": "workspace:^7.12.1" }, "peerDependencies": { diff --git a/packages/babel-preset-typescript/src/index.js b/packages/babel-preset-typescript/src/index.js index a6376d79dc11..6c244305bc9f 100644 --- a/packages/babel-preset-typescript/src/index.js +++ b/packages/babel-preset-typescript/src/index.js @@ -1,67 +1,67 @@ import { declare } from "@babel/helper-plugin-utils"; import transformTypeScript from "@babel/plugin-transform-typescript"; +import syntaxJSX from "@babel/plugin-syntax-jsx"; export default declare( ( api, { - allExtensions = false, - allowDeclareFields, + ignoreExtensions = false, allowNamespaces, jsxPragma, jsxPragmaFrag = "React.Fragment", - isTSX = false, onlyRemoveTypeImports, + + // Removed + allExtensions, + isTSX, }, ) => { api.assertVersion(7); - if (typeof jsxPragmaFrag !== "string") { - throw new Error(".jsxPragmaFrag must be a string, or undefined"); + if (typeof allExtensions !== "undefined" || typeof isTSX !== "undefined") { + throw new Error( + "The .allExtensions and .isTSX options have been removed.\n" + + "If you want to disable file extension-based JSX detection, " + + "you can set the .ignoreExtensions option to true.\n" + + "If you want to force JSX parsing, you can enable the " + + "@babel/plugin-syntax-jsx plugin.", + ); } - if (typeof allExtensions !== "boolean") { - throw new Error(".allExtensions must be a boolean, or undefined"); - } - - if (typeof isTSX !== "boolean") { - throw new Error(".isTSX must be a boolean, or undefined"); + if (typeof jsxPragmaFrag !== "string") { + throw new Error(".jsxPragmaFrag must be a string, or undefined"); } - if (isTSX && !allExtensions) { - throw new Error("isTSX:true requires allExtensions:true"); + if (typeof ignoreExtensions !== "boolean") { + throw new Error("The .ignoreExtensions option must be a boolean."); } - const pluginOptions = isTSX => ({ - allowDeclareFields, + const pluginOptions = { allowNamespaces, - isTSX, jsxPragma, jsxPragmaFrag, onlyRemoveTypeImports, - }); + }; + + const tsPlugins = [[transformTypeScript, pluginOptions]]; + const tsxPlugins = [[transformTypeScript, pluginOptions], syntaxJSX]; + + if (ignoreExtensions) { + return { plugins: tsPlugins }; + } return { - overrides: allExtensions - ? [ - { - plugins: [[transformTypeScript, pluginOptions(isTSX)]], - }, - ] - : [ - { - // Only set 'test' if explicitly requested, since it requires that - // Babel is being called` - test: /\.ts$/, - plugins: [[transformTypeScript, pluginOptions(false)]], - }, - { - // Only set 'test' if explicitly requested, since it requires that - // Babel is being called` - test: /\.tsx$/, - plugins: [[transformTypeScript, pluginOptions(true)]], - }, - ], + overrides: [ + { + test: filename => filename == null || filename.endsWith(".ts"), + plugins: tsPlugins, + }, + { + test: filename => filename?.endsWith(".tsx"), + plugins: tsxPlugins, + }, + ], }; }, ); diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-invalid/input.ts b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-invalid/input.ts new file mode 100644 index 000000000000..61bc88fec9fc --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-invalid/input.ts @@ -0,0 +1,2 @@ +// This is only valid in flow +import { type B } from "x"; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-invalid/options.json new file mode 100644 index 000000000000..22273adb98c5 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-invalid/options.json @@ -0,0 +1,8 @@ +{ + "sourceType": "module", + "presets": [ + ["flow", { "ignoreExtensions": true }], + "typescript" + ], + "throws": "Cannot combine flow and typescript plugins." +} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/input.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/input.js new file mode 100644 index 000000000000..61bc88fec9fc --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/input.js @@ -0,0 +1,2 @@ +// This is only valid in flow +import { type B } from "x"; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/options.json new file mode 100644 index 000000000000..43b274f190f0 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/options.json @@ -0,0 +1,7 @@ +{ + "sourceType": "module", + "presets": [ + ["flow", { "ignoreExtensions": true }], + "typescript" + ] +} diff --git a/packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/output.mjs b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/output.mjs similarity index 100% rename from packages/babel-preset-env/test/fixtures/corejs2/usage-remove-babel-polyfill-import/output.mjs rename to packages/babel-preset-typescript/test/fixtures/flow-compat/flow-ignoreExtensions-valid/output.mjs diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/input.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/input.js new file mode 100644 index 000000000000..61bc88fec9fc --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/input.js @@ -0,0 +1,2 @@ +// This is only valid in flow +import { type B } from "x"; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/options.json new file mode 100644 index 000000000000..9eb56ff4f783 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/options.json @@ -0,0 +1,4 @@ +{ + "sourceType": "module", + "presets": ["flow", "typescript"] +} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/output.mjs b/packages/babel-preset-typescript/test/fixtures/flow-compat/flow-valid/output.mjs new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-invalid/input.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/js-invalid/input.js deleted file mode 100644 index 7db07799f3f0..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-invalid/input.js +++ /dev/null @@ -1,5 +0,0 @@ -enum Example { - Value -} - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/js-invalid/options.json deleted file mode 100644 index fe0ad873dac4..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-invalid/options.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "presets": [["flow", {}, "before"], "typescript", ["flow", {}, "after"]], - "throws": "Unexpected reserved word 'enum' (1:0)" -} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-valid/input.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/js-valid/input.js deleted file mode 100644 index 8e28c22cd0d1..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-valid/input.js +++ /dev/null @@ -1,3 +0,0 @@ -type Foo = {||}; - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-valid/output.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/js-valid/output.js deleted file mode 100644 index e901f01b4874..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/js-valid/output.js +++ /dev/null @@ -1 +0,0 @@ -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/options.json deleted file mode 100644 index 2901adef575d..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "presets": [["flow", {}, "before"], "typescript", ["flow", {}, "after"]] -} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-invalid/input.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-invalid/input.js new file mode 100644 index 000000000000..106315f51609 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-invalid/input.js @@ -0,0 +1,3 @@ +// This is only valid in TypeScript + +type A = B extends C ? 1 : 2; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-invalid/options.json new file mode 100644 index 000000000000..0ca0366eb4f9 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-invalid/options.json @@ -0,0 +1,8 @@ +{ + "sourceType": "module", + "presets": [ + "flow", + ["typescript", { "ignoreExtensions": true }] + ], + "throws": "Cannot combine flow and typescript plugins." +} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/input.ts b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/input.ts new file mode 100644 index 000000000000..106315f51609 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/input.ts @@ -0,0 +1,3 @@ +// This is only valid in TypeScript + +type A = B extends C ? 1 : 2; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/options.json new file mode 100644 index 000000000000..d66816766963 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/options.json @@ -0,0 +1,7 @@ +{ + "sourceType": "module", + "presets": [ + "flow", + ["typescript", { "ignoreExtensions": true }] + ] +} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/output.mjs b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-ignoreExtensions-valid/output.mjs new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-invalid/input.ts b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-invalid/input.ts deleted file mode 100644 index 8e28c22cd0d1..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-invalid/input.ts +++ /dev/null @@ -1,3 +0,0 @@ -type Foo = {||}; - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-invalid/options.json deleted file mode 100644 index 8401da8eb45d..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-invalid/options.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "presets": [["flow", {}, "before"], "typescript", ["flow", {}, "after"]], - "throws": "Unexpected token (1:12)" -} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/input.ts b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/input.ts index 7db07799f3f0..106315f51609 100644 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/input.ts +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/input.ts @@ -1,5 +1,3 @@ -enum Example { - Value -} +// This is only valid in TypeScript -foo; +type A = B extends C ? 1 : 2; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/options.json new file mode 100644 index 000000000000..bd2d32dbdef4 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/options.json @@ -0,0 +1,4 @@ +{ + "sourceType": "module", + "presets": ["typescript", "flow"] +} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/output.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/output.js deleted file mode 100644 index 6f9ecaf0a46c..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/output.js +++ /dev/null @@ -1,7 +0,0 @@ -var Example; - -(function (Example) { - Example[Example["Value"] = 0] = "Value"; -})(Example || (Example = {})); - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/output.mjs b/packages/babel-preset-typescript/test/fixtures/flow-compat/ts-valid/output.mjs new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-invalid/input.tsx b/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-invalid/input.tsx deleted file mode 100644 index 8e28c22cd0d1..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-invalid/input.tsx +++ /dev/null @@ -1,3 +0,0 @@ -type Foo = {||}; - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-invalid/options.json deleted file mode 100644 index 8401da8eb45d..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-invalid/options.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "presets": [["flow", {}, "before"], "typescript", ["flow", {}, "after"]], - "throws": "Unexpected token (1:12)" -} diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-valid/input.tsx b/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-valid/input.tsx deleted file mode 100644 index 7db07799f3f0..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-valid/input.tsx +++ /dev/null @@ -1,5 +0,0 @@ -enum Example { - Value -} - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-valid/output.js b/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-valid/output.js deleted file mode 100644 index 6f9ecaf0a46c..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/flow-compat/tsx-valid/output.js +++ /dev/null @@ -1,7 +0,0 @@ -var Example; - -(function (Example) { - Example[Example["Value"] = 0] = "Value"; -})(Example || (Example = {})); - -foo; diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/js-valid/input.js b/packages/babel-preset-typescript/test/fixtures/jsx-compat/js-invalid/input.js similarity index 100% rename from packages/babel-preset-typescript/test/fixtures/jsx-compat/js-valid/input.js rename to packages/babel-preset-typescript/test/fixtures/jsx-compat/js-invalid/input.js diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/js-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/jsx-compat/js-invalid/options.json new file mode 100644 index 000000000000..b0b4df0551df --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/js-invalid/options.json @@ -0,0 +1,4 @@ +{ + "presets": ["typescript"], + "throws": "Support for the experimental syntax 'jsx' isn't currently enabled (1:2)" +} diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/options.json b/packages/babel-preset-typescript/test/fixtures/jsx-compat/options.json deleted file mode 100644 index a356e871159f..000000000000 --- a/packages/babel-preset-typescript/test/fixtures/jsx-compat/options.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "presets": [["react", {}, "before"], "typescript", ["react", {}, "after"]] -} diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/ts-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/jsx-compat/ts-invalid/options.json index c11cb6fdfbdf..f6bef11b7ee1 100644 --- a/packages/babel-preset-typescript/test/fixtures/jsx-compat/ts-invalid/options.json +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/ts-invalid/options.json @@ -1,3 +1,4 @@ { + "presets": ["typescript"], "throws": "Unexpected token, expected \",\" (1:6)" } diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-invalid/input.tsx b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-invalid/input.tsx new file mode 100644 index 000000000000..131f36bb7bbf --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-invalid/input.tsx @@ -0,0 +1 @@ +(
); diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-invalid/options.json b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-invalid/options.json new file mode 100644 index 000000000000..440436ce588a --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-invalid/options.json @@ -0,0 +1,6 @@ +{ + "presets": [ + ["typescript", { "ignoreExtensions": true }] + ], + "throws": "Unexpected token, expected \",\" (1:6)" +} diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/input.tsx b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/input.tsx new file mode 100644 index 000000000000..131f36bb7bbf --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/input.tsx @@ -0,0 +1 @@ +(
); diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/options.json b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/options.json new file mode 100644 index 000000000000..80db486197a8 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/options.json @@ -0,0 +1,6 @@ +{ + "presets": [ + ["typescript", { "ignoreExtensions": true }] + ], + "plugins": ["syntax-jsx"] +} diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/output.js b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/output.js new file mode 100644 index 000000000000..cbe1d12c589b --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-ignoreExtensions-with-jsx/output.js @@ -0,0 +1 @@ +
; diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/options.json b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/options.json new file mode 100644 index 000000000000..5f6d738a8c71 --- /dev/null +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/options.json @@ -0,0 +1,3 @@ +{ + "presets": ["typescript"] +} diff --git a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/output.js b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/output.js index 6ad0513bb203..cbe1d12c589b 100644 --- a/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/output.js +++ b/packages/babel-preset-typescript/test/fixtures/jsx-compat/tsx-valid/output.js @@ -1,2 +1 @@ -/*#__PURE__*/ -React.createElement("div", null); +
; diff --git a/packages/babel-register/package.json b/packages/babel-register/package.json index 4e0cbc3f4ba1..344def8497be 100644 --- a/packages/babel-register/package.json +++ b/packages/babel-register/package.json @@ -17,9 +17,9 @@ "./lib/node.js": "./lib/browser.js" }, "dependencies": { + "escape-string-regexp": "^4.0.0", "find-cache-dir": "^2.0.0", "lodash": "^4.17.19", - "make-dir": "^2.1.0", "pirates": "^4.0.0", "source-map-support": "^0.5.16" }, diff --git a/packages/babel-register/src/cache.js b/packages/babel-register/src/cache.js index 39eb9b78284b..8f135be70e43 100644 --- a/packages/babel-register/src/cache.js +++ b/packages/babel-register/src/cache.js @@ -1,7 +1,6 @@ import path from "path"; import fs from "fs"; import os from "os"; -import { sync as makeDirSync } from "make-dir"; import * as babel from "@babel/core"; import findCacheDir from "find-cache-dir"; @@ -39,7 +38,7 @@ export function save() { } try { - makeDirSync(path.dirname(FILENAME)); + fs.mkdirSync(path.dirname(FILENAME), { recursive: true }); fs.writeFileSync(FILENAME, serialised); } catch (e) { switch (e.code) { @@ -49,14 +48,14 @@ export function save() { case "EACCES": case "EPERM": console.warn( - `Babel could not write cache to file: ${FILENAME} + `Babel could not write cache to file: ${FILENAME} due to a permission issue. Cache is disabled.`, ); cacheDisabled = true; break; case "EROFS": console.warn( - `Babel could not write cache to file: ${FILENAME} + `Babel could not write cache to file: ${FILENAME} because it resides in a readonly filesystem. Cache is disabled.`, ); cacheDisabled = true; diff --git a/packages/babel-register/src/node.js b/packages/babel-register/src/node.js index ed527cdac549..eedd2985ea1e 100644 --- a/packages/babel-register/src/node.js +++ b/packages/babel-register/src/node.js @@ -1,7 +1,7 @@ import deepClone from "lodash/cloneDeep"; import sourceMapSupport from "source-map-support"; import * as registerCache from "./cache"; -import escapeRegExp from "lodash/escapeRegExp"; +import escapeRegExp from "escape-string-regexp"; import * as babel from "@babel/core"; import { OptionManager, DEFAULT_EXTENSIONS } from "@babel/core"; import { addHook } from "pirates"; diff --git a/packages/babel-standalone/test/babel.js b/packages/babel-standalone/test/babel.js index b17e9c50cea3..25b1271dcf70 100644 --- a/packages/babel-standalone/test/babel.js +++ b/packages/babel-standalone/test/babel.js @@ -23,7 +23,7 @@ }); it("handles the typescript preset", () => { const output = Babel.transform("var a: string;", { - presets: [["typescript", { allExtensions: true }]], + presets: ["typescript"], }).code; expect(output).toBe("var a;"); }); @@ -64,7 +64,7 @@ const output = Babel.transform( "const someDiv =
{getMessage()}
", { - presets: ["react"], + presets: [["react", { runtime: "classic" }]], }, ).code; expect(output).toBe( diff --git a/packages/babel-traverse/package.json b/packages/babel-traverse/package.json index 860965f1b5d2..7606b97cb4c1 100644 --- a/packages/babel-traverse/package.json +++ b/packages/babel-traverse/package.json @@ -22,7 +22,7 @@ "@babel/parser": "workspace:^7.12.1", "@babel/types": "workspace:^7.12.1", "debug": "^4.1.0", - "globals": "^11.1.0", + "globals": "^12.3.0", "lodash": "^4.17.19" }, "devDependencies": { diff --git a/packages/babel-traverse/src/path/inference/inferer-reference.js b/packages/babel-traverse/src/path/inference/inferer-reference.js index bb6ab6827ab8..c704935834a6 100644 --- a/packages/babel-traverse/src/path/inference/inferer-reference.js +++ b/packages/babel-traverse/src/path/inference/inferer-reference.js @@ -95,15 +95,11 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) { return; } - if (t.isTSTypeAnnotation(types[0]) && t.createTSUnionType) { + if (t.isTSTypeAnnotation(types[0])) { return t.createTSUnionType(types); } - if (t.createFlowUnionType) { - return t.createFlowUnionType(types); - } - - return t.createUnionTypeAnnotation(types); + return t.createFlowUnionType(types); } function getConstantViolationsBefore(binding, path, functions) { @@ -211,22 +207,15 @@ function getConditionalAnnotation(binding, path, name) { } if (types.length) { - if (t.isTSTypeAnnotation(types[0]) && t.createTSUnionType) { + if (t.isTSTypeAnnotation(types[0])) { return { typeAnnotation: t.createTSUnionType(types), ifStatement, }; } - if (t.createFlowUnionType) { - return { - typeAnnotation: t.createFlowUnionType(types), - ifStatement, - }; - } - return { - typeAnnotation: t.createUnionTypeAnnotation(types), + typeAnnotation: t.createFlowUnionType(types), ifStatement, }; } diff --git a/packages/babel-traverse/src/path/inference/inferers.js b/packages/babel-traverse/src/path/inference/inferers.js index 1b3de6cbd8c6..ca79f8e9e03e 100644 --- a/packages/babel-traverse/src/path/inference/inferers.js +++ b/packages/babel-traverse/src/path/inference/inferers.js @@ -88,15 +88,11 @@ export function LogicalExpression() { this.get("right").getTypeAnnotation(), ]; - if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) { + if (t.isTSTypeAnnotation(argumentTypes[0])) { return t.createTSUnionType(argumentTypes); } - if (t.createFlowUnionType) { - return t.createFlowUnionType(argumentTypes); - } - - return t.createUnionTypeAnnotation(argumentTypes); + return t.createFlowUnionType(argumentTypes); } export function ConditionalExpression() { @@ -105,15 +101,11 @@ export function ConditionalExpression() { this.get("alternate").getTypeAnnotation(), ]; - if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) { + if (t.isTSTypeAnnotation(argumentTypes[0])) { return t.createTSUnionType(argumentTypes); } - if (t.createFlowUnionType) { - return t.createFlowUnionType(argumentTypes); - } - - return t.createUnionTypeAnnotation(argumentTypes); + return t.createFlowUnionType(argumentTypes); } export function SequenceExpression() { diff --git a/packages/babel-types/scripts/generators/flow.js b/packages/babel-types/scripts/generators/flow.js index ade85fc49820..d3138cc90b5e 100644 --- a/packages/babel-types/scripts/generators/flow.js +++ b/packages/babel-types/scripts/generators/flow.js @@ -128,8 +128,6 @@ lines.push( // eslint-disable-next-line max-len `declare function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): ${NODE_PREFIX}TypeAnnotation`, // eslint-disable-next-line max-len - `declare function createUnionTypeAnnotation(types: Array<${NODE_PREFIX}FlowType>): ${NODE_PREFIX}UnionTypeAnnotation`, - // eslint-disable-next-line max-len `declare function createFlowUnionType(types: Array<${NODE_PREFIX}FlowType>): ${NODE_PREFIX}UnionTypeAnnotation`, // this smells like "internal API" // eslint-disable-next-line max-len diff --git a/packages/babel-types/scripts/generators/generateBuilders.js b/packages/babel-types/scripts/generators/generateBuilders.js index 5ca9f74643aa..d7ec3e424dc8 100644 --- a/packages/babel-types/scripts/generators/generateBuilders.js +++ b/packages/babel-types/scripts/generators/generateBuilders.js @@ -1,7 +1,6 @@ "use strict"; const definitions = require("../../lib/definitions"); const formatBuilderName = require("../utils/formatBuilderName"); -const lowerFirst = require("../utils/lowerFirst"); module.exports = function generateBuilders() { let output = `// @flow @@ -11,30 +10,9 @@ module.exports = function generateBuilders() { */ import builder from "../builder";\n\n`; - const reservedNames = new Set(["super", "import"]); Object.keys(definitions.BUILDER_KEYS).forEach(type => { - const formatedBuilderName = formatBuilderName(type); - const formatedBuilderNameLocal = reservedNames.has(formatedBuilderName) - ? `_${formatedBuilderName}` - : formatedBuilderName; - output += `${ - formatedBuilderNameLocal === formatedBuilderName ? "export " : "" - }function ${formatedBuilderNameLocal}(...args: Array): Object { return builder("${type}", ...args); }\n`; - // This is needed for backwards compatibility. - // arrayExpression -> ArrayExpression - output += `export { ${formatedBuilderNameLocal} as ${type} };\n`; - if (formatedBuilderNameLocal !== formatedBuilderName) { - output += `export { ${formatedBuilderNameLocal} as ${formatedBuilderName} };\n`; - } - - // This is needed for backwards compatibility. - // It should be removed in the next major version. - // JSXIdentifier -> jSXIdentifier - if (/^[A-Z]{2}/.test(type)) { - output += `export { ${formatedBuilderNameLocal} as ${lowerFirst( - type - )} }\n`; - } + output += `export function ${type}(...args: Array): Object { return builder("${type}", ...args); } +export { ${type} as ${formatBuilderName(type)} };\n`; }); Object.keys(definitions.DEPRECATED_KEYS).forEach(type => { @@ -44,13 +22,6 @@ import builder from "../builder";\n\n`; return builder("${type}", ...args); } export { ${type} as ${formatBuilderName(type)} };\n`; - - // This is needed for backwards compatibility. - // It should be removed in the next major version. - // JSXIdentifier -> jSXIdentifier - if (/^[A-Z]{2}/.test(type)) { - output += `export { ${type} as ${lowerFirst(type)} }\n`; - } }); return output; diff --git a/packages/babel-types/scripts/generators/typescript.js b/packages/babel-types/scripts/generators/typescript.js index 405d2e776aee..54e5454a0e63 100644 --- a/packages/babel-types/scripts/generators/typescript.js +++ b/packages/babel-types/scripts/generators/typescript.js @@ -144,11 +144,9 @@ lines.push( // builders/ // eslint-disable-next-line max-len `export function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): StringTypeAnnotation | VoidTypeAnnotation | NumberTypeAnnotation | BooleanTypeAnnotation | GenericTypeAnnotation`, - `export function createUnionTypeAnnotation(types: [T]): T`, `export function createFlowUnionType(types: [T]): T`, // this probably misbehaves if there are 0 elements, and it's not a UnionTypeAnnotation if there's only 1 // it is possible to require "2 or more" for this overload ([T, T, ...T[]]) but it requires typescript 3.0 - `export function createUnionTypeAnnotation(types: ReadonlyArray): UnionTypeAnnotation`, `export function createFlowUnionType(types: ReadonlyArray): UnionTypeAnnotation`, // this smells like "internal API" // eslint-disable-next-line max-len diff --git a/packages/babel-types/scripts/utils/lowerFirst.js b/packages/babel-types/scripts/utils/lowerFirst.js deleted file mode 100644 index 9e7b0cee51c1..000000000000 --- a/packages/babel-types/scripts/utils/lowerFirst.js +++ /dev/null @@ -1,4 +0,0 @@ -"use strict"; -module.exports = function lowerFirst(string) { - return string[0].toLowerCase() + string.slice(1); -}; diff --git a/packages/babel-types/src/builders/generated/index.js b/packages/babel-types/src/builders/generated/index.js index 02e19ab4a4a3..75f77819023f 100644 --- a/packages/babel-types/src/builders/generated/index.js +++ b/packages/babel-types/src/builders/generated/index.js @@ -5,1054 +5,974 @@ */ import builder from "../builder"; -export function arrayExpression(...args: Array): Object { +export function ArrayExpression(...args: Array): Object { return builder("ArrayExpression", ...args); } -export { arrayExpression as ArrayExpression }; -export function assignmentExpression(...args: Array): Object { +export { ArrayExpression as arrayExpression }; +export function AssignmentExpression(...args: Array): Object { return builder("AssignmentExpression", ...args); } -export { assignmentExpression as AssignmentExpression }; -export function binaryExpression(...args: Array): Object { +export { AssignmentExpression as assignmentExpression }; +export function BinaryExpression(...args: Array): Object { return builder("BinaryExpression", ...args); } -export { binaryExpression as BinaryExpression }; -export function interpreterDirective(...args: Array): Object { +export { BinaryExpression as binaryExpression }; +export function InterpreterDirective(...args: Array): Object { return builder("InterpreterDirective", ...args); } -export { interpreterDirective as InterpreterDirective }; -export function directive(...args: Array): Object { +export { InterpreterDirective as interpreterDirective }; +export function Directive(...args: Array): Object { return builder("Directive", ...args); } -export { directive as Directive }; -export function directiveLiteral(...args: Array): Object { +export { Directive as directive }; +export function DirectiveLiteral(...args: Array): Object { return builder("DirectiveLiteral", ...args); } -export { directiveLiteral as DirectiveLiteral }; -export function blockStatement(...args: Array): Object { +export { DirectiveLiteral as directiveLiteral }; +export function BlockStatement(...args: Array): Object { return builder("BlockStatement", ...args); } -export { blockStatement as BlockStatement }; -export function breakStatement(...args: Array): Object { +export { BlockStatement as blockStatement }; +export function BreakStatement(...args: Array): Object { return builder("BreakStatement", ...args); } -export { breakStatement as BreakStatement }; -export function callExpression(...args: Array): Object { +export { BreakStatement as breakStatement }; +export function CallExpression(...args: Array): Object { return builder("CallExpression", ...args); } -export { callExpression as CallExpression }; -export function catchClause(...args: Array): Object { +export { CallExpression as callExpression }; +export function CatchClause(...args: Array): Object { return builder("CatchClause", ...args); } -export { catchClause as CatchClause }; -export function conditionalExpression(...args: Array): Object { +export { CatchClause as catchClause }; +export function ConditionalExpression(...args: Array): Object { return builder("ConditionalExpression", ...args); } -export { conditionalExpression as ConditionalExpression }; -export function continueStatement(...args: Array): Object { +export { ConditionalExpression as conditionalExpression }; +export function ContinueStatement(...args: Array): Object { return builder("ContinueStatement", ...args); } -export { continueStatement as ContinueStatement }; -export function debuggerStatement(...args: Array): Object { +export { ContinueStatement as continueStatement }; +export function DebuggerStatement(...args: Array): Object { return builder("DebuggerStatement", ...args); } -export { debuggerStatement as DebuggerStatement }; -export function doWhileStatement(...args: Array): Object { +export { DebuggerStatement as debuggerStatement }; +export function DoWhileStatement(...args: Array): Object { return builder("DoWhileStatement", ...args); } -export { doWhileStatement as DoWhileStatement }; -export function emptyStatement(...args: Array): Object { +export { DoWhileStatement as doWhileStatement }; +export function EmptyStatement(...args: Array): Object { return builder("EmptyStatement", ...args); } -export { emptyStatement as EmptyStatement }; -export function expressionStatement(...args: Array): Object { +export { EmptyStatement as emptyStatement }; +export function ExpressionStatement(...args: Array): Object { return builder("ExpressionStatement", ...args); } -export { expressionStatement as ExpressionStatement }; -export function file(...args: Array): Object { +export { ExpressionStatement as expressionStatement }; +export function File(...args: Array): Object { return builder("File", ...args); } -export { file as File }; -export function forInStatement(...args: Array): Object { +export { File as file }; +export function ForInStatement(...args: Array): Object { return builder("ForInStatement", ...args); } -export { forInStatement as ForInStatement }; -export function forStatement(...args: Array): Object { +export { ForInStatement as forInStatement }; +export function ForStatement(...args: Array): Object { return builder("ForStatement", ...args); } -export { forStatement as ForStatement }; -export function functionDeclaration(...args: Array): Object { +export { ForStatement as forStatement }; +export function FunctionDeclaration(...args: Array): Object { return builder("FunctionDeclaration", ...args); } -export { functionDeclaration as FunctionDeclaration }; -export function functionExpression(...args: Array): Object { +export { FunctionDeclaration as functionDeclaration }; +export function FunctionExpression(...args: Array): Object { return builder("FunctionExpression", ...args); } -export { functionExpression as FunctionExpression }; -export function identifier(...args: Array): Object { +export { FunctionExpression as functionExpression }; +export function Identifier(...args: Array): Object { return builder("Identifier", ...args); } -export { identifier as Identifier }; -export function ifStatement(...args: Array): Object { +export { Identifier as identifier }; +export function IfStatement(...args: Array): Object { return builder("IfStatement", ...args); } -export { ifStatement as IfStatement }; -export function labeledStatement(...args: Array): Object { +export { IfStatement as ifStatement }; +export function LabeledStatement(...args: Array): Object { return builder("LabeledStatement", ...args); } -export { labeledStatement as LabeledStatement }; -export function stringLiteral(...args: Array): Object { +export { LabeledStatement as labeledStatement }; +export function StringLiteral(...args: Array): Object { return builder("StringLiteral", ...args); } -export { stringLiteral as StringLiteral }; -export function numericLiteral(...args: Array): Object { +export { StringLiteral as stringLiteral }; +export function NumericLiteral(...args: Array): Object { return builder("NumericLiteral", ...args); } -export { numericLiteral as NumericLiteral }; -export function nullLiteral(...args: Array): Object { +export { NumericLiteral as numericLiteral }; +export function NullLiteral(...args: Array): Object { return builder("NullLiteral", ...args); } -export { nullLiteral as NullLiteral }; -export function booleanLiteral(...args: Array): Object { +export { NullLiteral as nullLiteral }; +export function BooleanLiteral(...args: Array): Object { return builder("BooleanLiteral", ...args); } -export { booleanLiteral as BooleanLiteral }; -export function regExpLiteral(...args: Array): Object { +export { BooleanLiteral as booleanLiteral }; +export function RegExpLiteral(...args: Array): Object { return builder("RegExpLiteral", ...args); } -export { regExpLiteral as RegExpLiteral }; -export function logicalExpression(...args: Array): Object { +export { RegExpLiteral as regExpLiteral }; +export function LogicalExpression(...args: Array): Object { return builder("LogicalExpression", ...args); } -export { logicalExpression as LogicalExpression }; -export function memberExpression(...args: Array): Object { +export { LogicalExpression as logicalExpression }; +export function MemberExpression(...args: Array): Object { return builder("MemberExpression", ...args); } -export { memberExpression as MemberExpression }; -export function newExpression(...args: Array): Object { +export { MemberExpression as memberExpression }; +export function NewExpression(...args: Array): Object { return builder("NewExpression", ...args); } -export { newExpression as NewExpression }; -export function program(...args: Array): Object { +export { NewExpression as newExpression }; +export function Program(...args: Array): Object { return builder("Program", ...args); } -export { program as Program }; -export function objectExpression(...args: Array): Object { +export { Program as program }; +export function ObjectExpression(...args: Array): Object { return builder("ObjectExpression", ...args); } -export { objectExpression as ObjectExpression }; -export function objectMethod(...args: Array): Object { +export { ObjectExpression as objectExpression }; +export function ObjectMethod(...args: Array): Object { return builder("ObjectMethod", ...args); } -export { objectMethod as ObjectMethod }; -export function objectProperty(...args: Array): Object { +export { ObjectMethod as objectMethod }; +export function ObjectProperty(...args: Array): Object { return builder("ObjectProperty", ...args); } -export { objectProperty as ObjectProperty }; -export function restElement(...args: Array): Object { +export { ObjectProperty as objectProperty }; +export function RestElement(...args: Array): Object { return builder("RestElement", ...args); } -export { restElement as RestElement }; -export function returnStatement(...args: Array): Object { +export { RestElement as restElement }; +export function ReturnStatement(...args: Array): Object { return builder("ReturnStatement", ...args); } -export { returnStatement as ReturnStatement }; -export function sequenceExpression(...args: Array): Object { +export { ReturnStatement as returnStatement }; +export function SequenceExpression(...args: Array): Object { return builder("SequenceExpression", ...args); } -export { sequenceExpression as SequenceExpression }; -export function parenthesizedExpression(...args: Array): Object { +export { SequenceExpression as sequenceExpression }; +export function ParenthesizedExpression(...args: Array): Object { return builder("ParenthesizedExpression", ...args); } -export { parenthesizedExpression as ParenthesizedExpression }; -export function switchCase(...args: Array): Object { +export { ParenthesizedExpression as parenthesizedExpression }; +export function SwitchCase(...args: Array): Object { return builder("SwitchCase", ...args); } -export { switchCase as SwitchCase }; -export function switchStatement(...args: Array): Object { +export { SwitchCase as switchCase }; +export function SwitchStatement(...args: Array): Object { return builder("SwitchStatement", ...args); } -export { switchStatement as SwitchStatement }; -export function thisExpression(...args: Array): Object { +export { SwitchStatement as switchStatement }; +export function ThisExpression(...args: Array): Object { return builder("ThisExpression", ...args); } -export { thisExpression as ThisExpression }; -export function throwStatement(...args: Array): Object { +export { ThisExpression as thisExpression }; +export function ThrowStatement(...args: Array): Object { return builder("ThrowStatement", ...args); } -export { throwStatement as ThrowStatement }; -export function tryStatement(...args: Array): Object { +export { ThrowStatement as throwStatement }; +export function TryStatement(...args: Array): Object { return builder("TryStatement", ...args); } -export { tryStatement as TryStatement }; -export function unaryExpression(...args: Array): Object { +export { TryStatement as tryStatement }; +export function UnaryExpression(...args: Array): Object { return builder("UnaryExpression", ...args); } -export { unaryExpression as UnaryExpression }; -export function updateExpression(...args: Array): Object { +export { UnaryExpression as unaryExpression }; +export function UpdateExpression(...args: Array): Object { return builder("UpdateExpression", ...args); } -export { updateExpression as UpdateExpression }; -export function variableDeclaration(...args: Array): Object { +export { UpdateExpression as updateExpression }; +export function VariableDeclaration(...args: Array): Object { return builder("VariableDeclaration", ...args); } -export { variableDeclaration as VariableDeclaration }; -export function variableDeclarator(...args: Array): Object { +export { VariableDeclaration as variableDeclaration }; +export function VariableDeclarator(...args: Array): Object { return builder("VariableDeclarator", ...args); } -export { variableDeclarator as VariableDeclarator }; -export function whileStatement(...args: Array): Object { +export { VariableDeclarator as variableDeclarator }; +export function WhileStatement(...args: Array): Object { return builder("WhileStatement", ...args); } -export { whileStatement as WhileStatement }; -export function withStatement(...args: Array): Object { +export { WhileStatement as whileStatement }; +export function WithStatement(...args: Array): Object { return builder("WithStatement", ...args); } -export { withStatement as WithStatement }; -export function assignmentPattern(...args: Array): Object { +export { WithStatement as withStatement }; +export function AssignmentPattern(...args: Array): Object { return builder("AssignmentPattern", ...args); } -export { assignmentPattern as AssignmentPattern }; -export function arrayPattern(...args: Array): Object { +export { AssignmentPattern as assignmentPattern }; +export function ArrayPattern(...args: Array): Object { return builder("ArrayPattern", ...args); } -export { arrayPattern as ArrayPattern }; -export function arrowFunctionExpression(...args: Array): Object { +export { ArrayPattern as arrayPattern }; +export function ArrowFunctionExpression(...args: Array): Object { return builder("ArrowFunctionExpression", ...args); } -export { arrowFunctionExpression as ArrowFunctionExpression }; -export function classBody(...args: Array): Object { +export { ArrowFunctionExpression as arrowFunctionExpression }; +export function ClassBody(...args: Array): Object { return builder("ClassBody", ...args); } -export { classBody as ClassBody }; -export function classExpression(...args: Array): Object { +export { ClassBody as classBody }; +export function ClassExpression(...args: Array): Object { return builder("ClassExpression", ...args); } -export { classExpression as ClassExpression }; -export function classDeclaration(...args: Array): Object { +export { ClassExpression as classExpression }; +export function ClassDeclaration(...args: Array): Object { return builder("ClassDeclaration", ...args); } -export { classDeclaration as ClassDeclaration }; -export function exportAllDeclaration(...args: Array): Object { +export { ClassDeclaration as classDeclaration }; +export function ExportAllDeclaration(...args: Array): Object { return builder("ExportAllDeclaration", ...args); } -export { exportAllDeclaration as ExportAllDeclaration }; -export function exportDefaultDeclaration(...args: Array): Object { +export { ExportAllDeclaration as exportAllDeclaration }; +export function ExportDefaultDeclaration(...args: Array): Object { return builder("ExportDefaultDeclaration", ...args); } -export { exportDefaultDeclaration as ExportDefaultDeclaration }; -export function exportNamedDeclaration(...args: Array): Object { +export { ExportDefaultDeclaration as exportDefaultDeclaration }; +export function ExportNamedDeclaration(...args: Array): Object { return builder("ExportNamedDeclaration", ...args); } -export { exportNamedDeclaration as ExportNamedDeclaration }; -export function exportSpecifier(...args: Array): Object { +export { ExportNamedDeclaration as exportNamedDeclaration }; +export function ExportSpecifier(...args: Array): Object { return builder("ExportSpecifier", ...args); } -export { exportSpecifier as ExportSpecifier }; -export function forOfStatement(...args: Array): Object { +export { ExportSpecifier as exportSpecifier }; +export function ForOfStatement(...args: Array): Object { return builder("ForOfStatement", ...args); } -export { forOfStatement as ForOfStatement }; -export function importDeclaration(...args: Array): Object { +export { ForOfStatement as forOfStatement }; +export function ImportDeclaration(...args: Array): Object { return builder("ImportDeclaration", ...args); } -export { importDeclaration as ImportDeclaration }; -export function importDefaultSpecifier(...args: Array): Object { +export { ImportDeclaration as importDeclaration }; +export function ImportDefaultSpecifier(...args: Array): Object { return builder("ImportDefaultSpecifier", ...args); } -export { importDefaultSpecifier as ImportDefaultSpecifier }; -export function importNamespaceSpecifier(...args: Array): Object { +export { ImportDefaultSpecifier as importDefaultSpecifier }; +export function ImportNamespaceSpecifier(...args: Array): Object { return builder("ImportNamespaceSpecifier", ...args); } -export { importNamespaceSpecifier as ImportNamespaceSpecifier }; -export function importSpecifier(...args: Array): Object { +export { ImportNamespaceSpecifier as importNamespaceSpecifier }; +export function ImportSpecifier(...args: Array): Object { return builder("ImportSpecifier", ...args); } -export { importSpecifier as ImportSpecifier }; -export function metaProperty(...args: Array): Object { +export { ImportSpecifier as importSpecifier }; +export function MetaProperty(...args: Array): Object { return builder("MetaProperty", ...args); } -export { metaProperty as MetaProperty }; -export function classMethod(...args: Array): Object { +export { MetaProperty as metaProperty }; +export function ClassMethod(...args: Array): Object { return builder("ClassMethod", ...args); } -export { classMethod as ClassMethod }; -export function objectPattern(...args: Array): Object { +export { ClassMethod as classMethod }; +export function ObjectPattern(...args: Array): Object { return builder("ObjectPattern", ...args); } -export { objectPattern as ObjectPattern }; -export function spreadElement(...args: Array): Object { +export { ObjectPattern as objectPattern }; +export function SpreadElement(...args: Array): Object { return builder("SpreadElement", ...args); } -export { spreadElement as SpreadElement }; -function _super(...args: Array): Object { +export { SpreadElement as spreadElement }; +export function Super(...args: Array): Object { return builder("Super", ...args); } -export { _super as Super }; -export { _super as super }; -export function taggedTemplateExpression(...args: Array): Object { +export { Super as super }; +export function TaggedTemplateExpression(...args: Array): Object { return builder("TaggedTemplateExpression", ...args); } -export { taggedTemplateExpression as TaggedTemplateExpression }; -export function templateElement(...args: Array): Object { +export { TaggedTemplateExpression as taggedTemplateExpression }; +export function TemplateElement(...args: Array): Object { return builder("TemplateElement", ...args); } -export { templateElement as TemplateElement }; -export function templateLiteral(...args: Array): Object { +export { TemplateElement as templateElement }; +export function TemplateLiteral(...args: Array): Object { return builder("TemplateLiteral", ...args); } -export { templateLiteral as TemplateLiteral }; -export function yieldExpression(...args: Array): Object { +export { TemplateLiteral as templateLiteral }; +export function YieldExpression(...args: Array): Object { return builder("YieldExpression", ...args); } -export { yieldExpression as YieldExpression }; -export function awaitExpression(...args: Array): Object { +export { YieldExpression as yieldExpression }; +export function AwaitExpression(...args: Array): Object { return builder("AwaitExpression", ...args); } -export { awaitExpression as AwaitExpression }; -function _import(...args: Array): Object { +export { AwaitExpression as awaitExpression }; +export function Import(...args: Array): Object { return builder("Import", ...args); } -export { _import as Import }; -export { _import as import }; -export function bigIntLiteral(...args: Array): Object { +export { Import as import }; +export function BigIntLiteral(...args: Array): Object { return builder("BigIntLiteral", ...args); } -export { bigIntLiteral as BigIntLiteral }; -export function exportNamespaceSpecifier(...args: Array): Object { +export { BigIntLiteral as bigIntLiteral }; +export function ExportNamespaceSpecifier(...args: Array): Object { return builder("ExportNamespaceSpecifier", ...args); } -export { exportNamespaceSpecifier as ExportNamespaceSpecifier }; -export function optionalMemberExpression(...args: Array): Object { +export { ExportNamespaceSpecifier as exportNamespaceSpecifier }; +export function OptionalMemberExpression(...args: Array): Object { return builder("OptionalMemberExpression", ...args); } -export { optionalMemberExpression as OptionalMemberExpression }; -export function optionalCallExpression(...args: Array): Object { +export { OptionalMemberExpression as optionalMemberExpression }; +export function OptionalCallExpression(...args: Array): Object { return builder("OptionalCallExpression", ...args); } -export { optionalCallExpression as OptionalCallExpression }; -export function anyTypeAnnotation(...args: Array): Object { +export { OptionalCallExpression as optionalCallExpression }; +export function AnyTypeAnnotation(...args: Array): Object { return builder("AnyTypeAnnotation", ...args); } -export { anyTypeAnnotation as AnyTypeAnnotation }; -export function arrayTypeAnnotation(...args: Array): Object { +export { AnyTypeAnnotation as anyTypeAnnotation }; +export function ArrayTypeAnnotation(...args: Array): Object { return builder("ArrayTypeAnnotation", ...args); } -export { arrayTypeAnnotation as ArrayTypeAnnotation }; -export function booleanTypeAnnotation(...args: Array): Object { +export { ArrayTypeAnnotation as arrayTypeAnnotation }; +export function BooleanTypeAnnotation(...args: Array): Object { return builder("BooleanTypeAnnotation", ...args); } -export { booleanTypeAnnotation as BooleanTypeAnnotation }; -export function booleanLiteralTypeAnnotation(...args: Array): Object { +export { BooleanTypeAnnotation as booleanTypeAnnotation }; +export function BooleanLiteralTypeAnnotation(...args: Array): Object { return builder("BooleanLiteralTypeAnnotation", ...args); } -export { booleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotation }; -export function nullLiteralTypeAnnotation(...args: Array): Object { +export { BooleanLiteralTypeAnnotation as booleanLiteralTypeAnnotation }; +export function NullLiteralTypeAnnotation(...args: Array): Object { return builder("NullLiteralTypeAnnotation", ...args); } -export { nullLiteralTypeAnnotation as NullLiteralTypeAnnotation }; -export function classImplements(...args: Array): Object { +export { NullLiteralTypeAnnotation as nullLiteralTypeAnnotation }; +export function ClassImplements(...args: Array): Object { return builder("ClassImplements", ...args); } -export { classImplements as ClassImplements }; -export function declareClass(...args: Array): Object { +export { ClassImplements as classImplements }; +export function DeclareClass(...args: Array): Object { return builder("DeclareClass", ...args); } -export { declareClass as DeclareClass }; -export function declareFunction(...args: Array): Object { +export { DeclareClass as declareClass }; +export function DeclareFunction(...args: Array): Object { return builder("DeclareFunction", ...args); } -export { declareFunction as DeclareFunction }; -export function declareInterface(...args: Array): Object { +export { DeclareFunction as declareFunction }; +export function DeclareInterface(...args: Array): Object { return builder("DeclareInterface", ...args); } -export { declareInterface as DeclareInterface }; -export function declareModule(...args: Array): Object { +export { DeclareInterface as declareInterface }; +export function DeclareModule(...args: Array): Object { return builder("DeclareModule", ...args); } -export { declareModule as DeclareModule }; -export function declareModuleExports(...args: Array): Object { +export { DeclareModule as declareModule }; +export function DeclareModuleExports(...args: Array): Object { return builder("DeclareModuleExports", ...args); } -export { declareModuleExports as DeclareModuleExports }; -export function declareTypeAlias(...args: Array): Object { +export { DeclareModuleExports as declareModuleExports }; +export function DeclareTypeAlias(...args: Array): Object { return builder("DeclareTypeAlias", ...args); } -export { declareTypeAlias as DeclareTypeAlias }; -export function declareOpaqueType(...args: Array): Object { +export { DeclareTypeAlias as declareTypeAlias }; +export function DeclareOpaqueType(...args: Array): Object { return builder("DeclareOpaqueType", ...args); } -export { declareOpaqueType as DeclareOpaqueType }; -export function declareVariable(...args: Array): Object { +export { DeclareOpaqueType as declareOpaqueType }; +export function DeclareVariable(...args: Array): Object { return builder("DeclareVariable", ...args); } -export { declareVariable as DeclareVariable }; -export function declareExportDeclaration(...args: Array): Object { +export { DeclareVariable as declareVariable }; +export function DeclareExportDeclaration(...args: Array): Object { return builder("DeclareExportDeclaration", ...args); } -export { declareExportDeclaration as DeclareExportDeclaration }; -export function declareExportAllDeclaration(...args: Array): Object { +export { DeclareExportDeclaration as declareExportDeclaration }; +export function DeclareExportAllDeclaration(...args: Array): Object { return builder("DeclareExportAllDeclaration", ...args); } -export { declareExportAllDeclaration as DeclareExportAllDeclaration }; -export function declaredPredicate(...args: Array): Object { +export { DeclareExportAllDeclaration as declareExportAllDeclaration }; +export function DeclaredPredicate(...args: Array): Object { return builder("DeclaredPredicate", ...args); } -export { declaredPredicate as DeclaredPredicate }; -export function existsTypeAnnotation(...args: Array): Object { +export { DeclaredPredicate as declaredPredicate }; +export function ExistsTypeAnnotation(...args: Array): Object { return builder("ExistsTypeAnnotation", ...args); } -export { existsTypeAnnotation as ExistsTypeAnnotation }; -export function functionTypeAnnotation(...args: Array): Object { +export { ExistsTypeAnnotation as existsTypeAnnotation }; +export function FunctionTypeAnnotation(...args: Array): Object { return builder("FunctionTypeAnnotation", ...args); } -export { functionTypeAnnotation as FunctionTypeAnnotation }; -export function functionTypeParam(...args: Array): Object { +export { FunctionTypeAnnotation as functionTypeAnnotation }; +export function FunctionTypeParam(...args: Array): Object { return builder("FunctionTypeParam", ...args); } -export { functionTypeParam as FunctionTypeParam }; -export function genericTypeAnnotation(...args: Array): Object { +export { FunctionTypeParam as functionTypeParam }; +export function GenericTypeAnnotation(...args: Array): Object { return builder("GenericTypeAnnotation", ...args); } -export { genericTypeAnnotation as GenericTypeAnnotation }; -export function inferredPredicate(...args: Array): Object { +export { GenericTypeAnnotation as genericTypeAnnotation }; +export function InferredPredicate(...args: Array): Object { return builder("InferredPredicate", ...args); } -export { inferredPredicate as InferredPredicate }; -export function interfaceExtends(...args: Array): Object { +export { InferredPredicate as inferredPredicate }; +export function InterfaceExtends(...args: Array): Object { return builder("InterfaceExtends", ...args); } -export { interfaceExtends as InterfaceExtends }; -export function interfaceDeclaration(...args: Array): Object { +export { InterfaceExtends as interfaceExtends }; +export function InterfaceDeclaration(...args: Array): Object { return builder("InterfaceDeclaration", ...args); } -export { interfaceDeclaration as InterfaceDeclaration }; -export function interfaceTypeAnnotation(...args: Array): Object { +export { InterfaceDeclaration as interfaceDeclaration }; +export function InterfaceTypeAnnotation(...args: Array): Object { return builder("InterfaceTypeAnnotation", ...args); } -export { interfaceTypeAnnotation as InterfaceTypeAnnotation }; -export function intersectionTypeAnnotation(...args: Array): Object { +export { InterfaceTypeAnnotation as interfaceTypeAnnotation }; +export function IntersectionTypeAnnotation(...args: Array): Object { return builder("IntersectionTypeAnnotation", ...args); } -export { intersectionTypeAnnotation as IntersectionTypeAnnotation }; -export function mixedTypeAnnotation(...args: Array): Object { +export { IntersectionTypeAnnotation as intersectionTypeAnnotation }; +export function MixedTypeAnnotation(...args: Array): Object { return builder("MixedTypeAnnotation", ...args); } -export { mixedTypeAnnotation as MixedTypeAnnotation }; -export function emptyTypeAnnotation(...args: Array): Object { +export { MixedTypeAnnotation as mixedTypeAnnotation }; +export function EmptyTypeAnnotation(...args: Array): Object { return builder("EmptyTypeAnnotation", ...args); } -export { emptyTypeAnnotation as EmptyTypeAnnotation }; -export function nullableTypeAnnotation(...args: Array): Object { +export { EmptyTypeAnnotation as emptyTypeAnnotation }; +export function NullableTypeAnnotation(...args: Array): Object { return builder("NullableTypeAnnotation", ...args); } -export { nullableTypeAnnotation as NullableTypeAnnotation }; -export function numberLiteralTypeAnnotation(...args: Array): Object { +export { NullableTypeAnnotation as nullableTypeAnnotation }; +export function NumberLiteralTypeAnnotation(...args: Array): Object { return builder("NumberLiteralTypeAnnotation", ...args); } -export { numberLiteralTypeAnnotation as NumberLiteralTypeAnnotation }; -export function numberTypeAnnotation(...args: Array): Object { +export { NumberLiteralTypeAnnotation as numberLiteralTypeAnnotation }; +export function NumberTypeAnnotation(...args: Array): Object { return builder("NumberTypeAnnotation", ...args); } -export { numberTypeAnnotation as NumberTypeAnnotation }; -export function objectTypeAnnotation(...args: Array): Object { +export { NumberTypeAnnotation as numberTypeAnnotation }; +export function ObjectTypeAnnotation(...args: Array): Object { return builder("ObjectTypeAnnotation", ...args); } -export { objectTypeAnnotation as ObjectTypeAnnotation }; -export function objectTypeInternalSlot(...args: Array): Object { +export { ObjectTypeAnnotation as objectTypeAnnotation }; +export function ObjectTypeInternalSlot(...args: Array): Object { return builder("ObjectTypeInternalSlot", ...args); } -export { objectTypeInternalSlot as ObjectTypeInternalSlot }; -export function objectTypeCallProperty(...args: Array): Object { +export { ObjectTypeInternalSlot as objectTypeInternalSlot }; +export function ObjectTypeCallProperty(...args: Array): Object { return builder("ObjectTypeCallProperty", ...args); } -export { objectTypeCallProperty as ObjectTypeCallProperty }; -export function objectTypeIndexer(...args: Array): Object { +export { ObjectTypeCallProperty as objectTypeCallProperty }; +export function ObjectTypeIndexer(...args: Array): Object { return builder("ObjectTypeIndexer", ...args); } -export { objectTypeIndexer as ObjectTypeIndexer }; -export function objectTypeProperty(...args: Array): Object { +export { ObjectTypeIndexer as objectTypeIndexer }; +export function ObjectTypeProperty(...args: Array): Object { return builder("ObjectTypeProperty", ...args); } -export { objectTypeProperty as ObjectTypeProperty }; -export function objectTypeSpreadProperty(...args: Array): Object { +export { ObjectTypeProperty as objectTypeProperty }; +export function ObjectTypeSpreadProperty(...args: Array): Object { return builder("ObjectTypeSpreadProperty", ...args); } -export { objectTypeSpreadProperty as ObjectTypeSpreadProperty }; -export function opaqueType(...args: Array): Object { +export { ObjectTypeSpreadProperty as objectTypeSpreadProperty }; +export function OpaqueType(...args: Array): Object { return builder("OpaqueType", ...args); } -export { opaqueType as OpaqueType }; -export function qualifiedTypeIdentifier(...args: Array): Object { +export { OpaqueType as opaqueType }; +export function QualifiedTypeIdentifier(...args: Array): Object { return builder("QualifiedTypeIdentifier", ...args); } -export { qualifiedTypeIdentifier as QualifiedTypeIdentifier }; -export function stringLiteralTypeAnnotation(...args: Array): Object { +export { QualifiedTypeIdentifier as qualifiedTypeIdentifier }; +export function StringLiteralTypeAnnotation(...args: Array): Object { return builder("StringLiteralTypeAnnotation", ...args); } -export { stringLiteralTypeAnnotation as StringLiteralTypeAnnotation }; -export function stringTypeAnnotation(...args: Array): Object { +export { StringLiteralTypeAnnotation as stringLiteralTypeAnnotation }; +export function StringTypeAnnotation(...args: Array): Object { return builder("StringTypeAnnotation", ...args); } -export { stringTypeAnnotation as StringTypeAnnotation }; -export function symbolTypeAnnotation(...args: Array): Object { +export { StringTypeAnnotation as stringTypeAnnotation }; +export function SymbolTypeAnnotation(...args: Array): Object { return builder("SymbolTypeAnnotation", ...args); } -export { symbolTypeAnnotation as SymbolTypeAnnotation }; -export function thisTypeAnnotation(...args: Array): Object { +export { SymbolTypeAnnotation as symbolTypeAnnotation }; +export function ThisTypeAnnotation(...args: Array): Object { return builder("ThisTypeAnnotation", ...args); } -export { thisTypeAnnotation as ThisTypeAnnotation }; -export function tupleTypeAnnotation(...args: Array): Object { +export { ThisTypeAnnotation as thisTypeAnnotation }; +export function TupleTypeAnnotation(...args: Array): Object { return builder("TupleTypeAnnotation", ...args); } -export { tupleTypeAnnotation as TupleTypeAnnotation }; -export function typeofTypeAnnotation(...args: Array): Object { +export { TupleTypeAnnotation as tupleTypeAnnotation }; +export function TypeofTypeAnnotation(...args: Array): Object { return builder("TypeofTypeAnnotation", ...args); } -export { typeofTypeAnnotation as TypeofTypeAnnotation }; -export function typeAlias(...args: Array): Object { +export { TypeofTypeAnnotation as typeofTypeAnnotation }; +export function TypeAlias(...args: Array): Object { return builder("TypeAlias", ...args); } -export { typeAlias as TypeAlias }; -export function typeAnnotation(...args: Array): Object { +export { TypeAlias as typeAlias }; +export function TypeAnnotation(...args: Array): Object { return builder("TypeAnnotation", ...args); } -export { typeAnnotation as TypeAnnotation }; -export function typeCastExpression(...args: Array): Object { +export { TypeAnnotation as typeAnnotation }; +export function TypeCastExpression(...args: Array): Object { return builder("TypeCastExpression", ...args); } -export { typeCastExpression as TypeCastExpression }; -export function typeParameter(...args: Array): Object { +export { TypeCastExpression as typeCastExpression }; +export function TypeParameter(...args: Array): Object { return builder("TypeParameter", ...args); } -export { typeParameter as TypeParameter }; -export function typeParameterDeclaration(...args: Array): Object { +export { TypeParameter as typeParameter }; +export function TypeParameterDeclaration(...args: Array): Object { return builder("TypeParameterDeclaration", ...args); } -export { typeParameterDeclaration as TypeParameterDeclaration }; -export function typeParameterInstantiation(...args: Array): Object { +export { TypeParameterDeclaration as typeParameterDeclaration }; +export function TypeParameterInstantiation(...args: Array): Object { return builder("TypeParameterInstantiation", ...args); } -export { typeParameterInstantiation as TypeParameterInstantiation }; -export function unionTypeAnnotation(...args: Array): Object { +export { TypeParameterInstantiation as typeParameterInstantiation }; +export function UnionTypeAnnotation(...args: Array): Object { return builder("UnionTypeAnnotation", ...args); } -export { unionTypeAnnotation as UnionTypeAnnotation }; -export function variance(...args: Array): Object { +export { UnionTypeAnnotation as unionTypeAnnotation }; +export function Variance(...args: Array): Object { return builder("Variance", ...args); } -export { variance as Variance }; -export function voidTypeAnnotation(...args: Array): Object { +export { Variance as variance }; +export function VoidTypeAnnotation(...args: Array): Object { return builder("VoidTypeAnnotation", ...args); } -export { voidTypeAnnotation as VoidTypeAnnotation }; -export function enumDeclaration(...args: Array): Object { +export { VoidTypeAnnotation as voidTypeAnnotation }; +export function EnumDeclaration(...args: Array): Object { return builder("EnumDeclaration", ...args); } -export { enumDeclaration as EnumDeclaration }; -export function enumBooleanBody(...args: Array): Object { +export { EnumDeclaration as enumDeclaration }; +export function EnumBooleanBody(...args: Array): Object { return builder("EnumBooleanBody", ...args); } -export { enumBooleanBody as EnumBooleanBody }; -export function enumNumberBody(...args: Array): Object { +export { EnumBooleanBody as enumBooleanBody }; +export function EnumNumberBody(...args: Array): Object { return builder("EnumNumberBody", ...args); } -export { enumNumberBody as EnumNumberBody }; -export function enumStringBody(...args: Array): Object { +export { EnumNumberBody as enumNumberBody }; +export function EnumStringBody(...args: Array): Object { return builder("EnumStringBody", ...args); } -export { enumStringBody as EnumStringBody }; -export function enumSymbolBody(...args: Array): Object { +export { EnumStringBody as enumStringBody }; +export function EnumSymbolBody(...args: Array): Object { return builder("EnumSymbolBody", ...args); } -export { enumSymbolBody as EnumSymbolBody }; -export function enumBooleanMember(...args: Array): Object { +export { EnumSymbolBody as enumSymbolBody }; +export function EnumBooleanMember(...args: Array): Object { return builder("EnumBooleanMember", ...args); } -export { enumBooleanMember as EnumBooleanMember }; -export function enumNumberMember(...args: Array): Object { +export { EnumBooleanMember as enumBooleanMember }; +export function EnumNumberMember(...args: Array): Object { return builder("EnumNumberMember", ...args); } -export { enumNumberMember as EnumNumberMember }; -export function enumStringMember(...args: Array): Object { +export { EnumNumberMember as enumNumberMember }; +export function EnumStringMember(...args: Array): Object { return builder("EnumStringMember", ...args); } -export { enumStringMember as EnumStringMember }; -export function enumDefaultedMember(...args: Array): Object { +export { EnumStringMember as enumStringMember }; +export function EnumDefaultedMember(...args: Array): Object { return builder("EnumDefaultedMember", ...args); } -export { enumDefaultedMember as EnumDefaultedMember }; -export function jsxAttribute(...args: Array): Object { +export { EnumDefaultedMember as enumDefaultedMember }; +export function JSXAttribute(...args: Array): Object { return builder("JSXAttribute", ...args); } -export { jsxAttribute as JSXAttribute }; -export { jsxAttribute as jSXAttribute }; -export function jsxClosingElement(...args: Array): Object { +export { JSXAttribute as jsxAttribute }; +export function JSXClosingElement(...args: Array): Object { return builder("JSXClosingElement", ...args); } -export { jsxClosingElement as JSXClosingElement }; -export { jsxClosingElement as jSXClosingElement }; -export function jsxElement(...args: Array): Object { +export { JSXClosingElement as jsxClosingElement }; +export function JSXElement(...args: Array): Object { return builder("JSXElement", ...args); } -export { jsxElement as JSXElement }; -export { jsxElement as jSXElement }; -export function jsxEmptyExpression(...args: Array): Object { +export { JSXElement as jsxElement }; +export function JSXEmptyExpression(...args: Array): Object { return builder("JSXEmptyExpression", ...args); } -export { jsxEmptyExpression as JSXEmptyExpression }; -export { jsxEmptyExpression as jSXEmptyExpression }; -export function jsxExpressionContainer(...args: Array): Object { +export { JSXEmptyExpression as jsxEmptyExpression }; +export function JSXExpressionContainer(...args: Array): Object { return builder("JSXExpressionContainer", ...args); } -export { jsxExpressionContainer as JSXExpressionContainer }; -export { jsxExpressionContainer as jSXExpressionContainer }; -export function jsxSpreadChild(...args: Array): Object { +export { JSXExpressionContainer as jsxExpressionContainer }; +export function JSXSpreadChild(...args: Array): Object { return builder("JSXSpreadChild", ...args); } -export { jsxSpreadChild as JSXSpreadChild }; -export { jsxSpreadChild as jSXSpreadChild }; -export function jsxIdentifier(...args: Array): Object { +export { JSXSpreadChild as jsxSpreadChild }; +export function JSXIdentifier(...args: Array): Object { return builder("JSXIdentifier", ...args); } -export { jsxIdentifier as JSXIdentifier }; -export { jsxIdentifier as jSXIdentifier }; -export function jsxMemberExpression(...args: Array): Object { +export { JSXIdentifier as jsxIdentifier }; +export function JSXMemberExpression(...args: Array): Object { return builder("JSXMemberExpression", ...args); } -export { jsxMemberExpression as JSXMemberExpression }; -export { jsxMemberExpression as jSXMemberExpression }; -export function jsxNamespacedName(...args: Array): Object { +export { JSXMemberExpression as jsxMemberExpression }; +export function JSXNamespacedName(...args: Array): Object { return builder("JSXNamespacedName", ...args); } -export { jsxNamespacedName as JSXNamespacedName }; -export { jsxNamespacedName as jSXNamespacedName }; -export function jsxOpeningElement(...args: Array): Object { +export { JSXNamespacedName as jsxNamespacedName }; +export function JSXOpeningElement(...args: Array): Object { return builder("JSXOpeningElement", ...args); } -export { jsxOpeningElement as JSXOpeningElement }; -export { jsxOpeningElement as jSXOpeningElement }; -export function jsxSpreadAttribute(...args: Array): Object { +export { JSXOpeningElement as jsxOpeningElement }; +export function JSXSpreadAttribute(...args: Array): Object { return builder("JSXSpreadAttribute", ...args); } -export { jsxSpreadAttribute as JSXSpreadAttribute }; -export { jsxSpreadAttribute as jSXSpreadAttribute }; -export function jsxText(...args: Array): Object { +export { JSXSpreadAttribute as jsxSpreadAttribute }; +export function JSXText(...args: Array): Object { return builder("JSXText", ...args); } -export { jsxText as JSXText }; -export { jsxText as jSXText }; -export function jsxFragment(...args: Array): Object { +export { JSXText as jsxText }; +export function JSXFragment(...args: Array): Object { return builder("JSXFragment", ...args); } -export { jsxFragment as JSXFragment }; -export { jsxFragment as jSXFragment }; -export function jsxOpeningFragment(...args: Array): Object { +export { JSXFragment as jsxFragment }; +export function JSXOpeningFragment(...args: Array): Object { return builder("JSXOpeningFragment", ...args); } -export { jsxOpeningFragment as JSXOpeningFragment }; -export { jsxOpeningFragment as jSXOpeningFragment }; -export function jsxClosingFragment(...args: Array): Object { +export { JSXOpeningFragment as jsxOpeningFragment }; +export function JSXClosingFragment(...args: Array): Object { return builder("JSXClosingFragment", ...args); } -export { jsxClosingFragment as JSXClosingFragment }; -export { jsxClosingFragment as jSXClosingFragment }; -export function noop(...args: Array): Object { +export { JSXClosingFragment as jsxClosingFragment }; +export function Noop(...args: Array): Object { return builder("Noop", ...args); } -export { noop as Noop }; -export function placeholder(...args: Array): Object { +export { Noop as noop }; +export function Placeholder(...args: Array): Object { return builder("Placeholder", ...args); } -export { placeholder as Placeholder }; -export function v8IntrinsicIdentifier(...args: Array): Object { +export { Placeholder as placeholder }; +export function V8IntrinsicIdentifier(...args: Array): Object { return builder("V8IntrinsicIdentifier", ...args); } -export { v8IntrinsicIdentifier as V8IntrinsicIdentifier }; -export function argumentPlaceholder(...args: Array): Object { +export { V8IntrinsicIdentifier as v8IntrinsicIdentifier }; +export function ArgumentPlaceholder(...args: Array): Object { return builder("ArgumentPlaceholder", ...args); } -export { argumentPlaceholder as ArgumentPlaceholder }; -export function bindExpression(...args: Array): Object { +export { ArgumentPlaceholder as argumentPlaceholder }; +export function BindExpression(...args: Array): Object { return builder("BindExpression", ...args); } -export { bindExpression as BindExpression }; -export function classProperty(...args: Array): Object { +export { BindExpression as bindExpression }; +export function ClassProperty(...args: Array): Object { return builder("ClassProperty", ...args); } -export { classProperty as ClassProperty }; -export function pipelineTopicExpression(...args: Array): Object { +export { ClassProperty as classProperty }; +export function PipelineTopicExpression(...args: Array): Object { return builder("PipelineTopicExpression", ...args); } -export { pipelineTopicExpression as PipelineTopicExpression }; -export function pipelineBareFunction(...args: Array): Object { +export { PipelineTopicExpression as pipelineTopicExpression }; +export function PipelineBareFunction(...args: Array): Object { return builder("PipelineBareFunction", ...args); } -export { pipelineBareFunction as PipelineBareFunction }; -export function pipelinePrimaryTopicReference(...args: Array): Object { +export { PipelineBareFunction as pipelineBareFunction }; +export function PipelinePrimaryTopicReference(...args: Array): Object { return builder("PipelinePrimaryTopicReference", ...args); } -export { pipelinePrimaryTopicReference as PipelinePrimaryTopicReference }; -export function classPrivateProperty(...args: Array): Object { +export { PipelinePrimaryTopicReference as pipelinePrimaryTopicReference }; +export function ClassPrivateProperty(...args: Array): Object { return builder("ClassPrivateProperty", ...args); } -export { classPrivateProperty as ClassPrivateProperty }; -export function classPrivateMethod(...args: Array): Object { +export { ClassPrivateProperty as classPrivateProperty }; +export function ClassPrivateMethod(...args: Array): Object { return builder("ClassPrivateMethod", ...args); } -export { classPrivateMethod as ClassPrivateMethod }; -export function importAttribute(...args: Array): Object { +export { ClassPrivateMethod as classPrivateMethod }; +export function ImportAttribute(...args: Array): Object { return builder("ImportAttribute", ...args); } -export { importAttribute as ImportAttribute }; -export function decorator(...args: Array): Object { +export { ImportAttribute as importAttribute }; +export function Decorator(...args: Array): Object { return builder("Decorator", ...args); } -export { decorator as Decorator }; -export function doExpression(...args: Array): Object { +export { Decorator as decorator }; +export function DoExpression(...args: Array): Object { return builder("DoExpression", ...args); } -export { doExpression as DoExpression }; -export function exportDefaultSpecifier(...args: Array): Object { +export { DoExpression as doExpression }; +export function ExportDefaultSpecifier(...args: Array): Object { return builder("ExportDefaultSpecifier", ...args); } -export { exportDefaultSpecifier as ExportDefaultSpecifier }; -export function privateName(...args: Array): Object { +export { ExportDefaultSpecifier as exportDefaultSpecifier }; +export function PrivateName(...args: Array): Object { return builder("PrivateName", ...args); } -export { privateName as PrivateName }; -export function recordExpression(...args: Array): Object { +export { PrivateName as privateName }; +export function RecordExpression(...args: Array): Object { return builder("RecordExpression", ...args); } -export { recordExpression as RecordExpression }; -export function tupleExpression(...args: Array): Object { +export { RecordExpression as recordExpression }; +export function TupleExpression(...args: Array): Object { return builder("TupleExpression", ...args); } -export { tupleExpression as TupleExpression }; -export function decimalLiteral(...args: Array): Object { +export { TupleExpression as tupleExpression }; +export function DecimalLiteral(...args: Array): Object { return builder("DecimalLiteral", ...args); } -export { decimalLiteral as DecimalLiteral }; -export function staticBlock(...args: Array): Object { +export { DecimalLiteral as decimalLiteral }; +export function StaticBlock(...args: Array): Object { return builder("StaticBlock", ...args); } -export { staticBlock as StaticBlock }; -export function tsParameterProperty(...args: Array): Object { +export { StaticBlock as staticBlock }; +export function TSParameterProperty(...args: Array): Object { return builder("TSParameterProperty", ...args); } -export { tsParameterProperty as TSParameterProperty }; -export { tsParameterProperty as tSParameterProperty }; -export function tsDeclareFunction(...args: Array): Object { +export { TSParameterProperty as tsParameterProperty }; +export function TSDeclareFunction(...args: Array): Object { return builder("TSDeclareFunction", ...args); } -export { tsDeclareFunction as TSDeclareFunction }; -export { tsDeclareFunction as tSDeclareFunction }; -export function tsDeclareMethod(...args: Array): Object { +export { TSDeclareFunction as tsDeclareFunction }; +export function TSDeclareMethod(...args: Array): Object { return builder("TSDeclareMethod", ...args); } -export { tsDeclareMethod as TSDeclareMethod }; -export { tsDeclareMethod as tSDeclareMethod }; -export function tsQualifiedName(...args: Array): Object { +export { TSDeclareMethod as tsDeclareMethod }; +export function TSQualifiedName(...args: Array): Object { return builder("TSQualifiedName", ...args); } -export { tsQualifiedName as TSQualifiedName }; -export { tsQualifiedName as tSQualifiedName }; -export function tsCallSignatureDeclaration(...args: Array): Object { +export { TSQualifiedName as tsQualifiedName }; +export function TSCallSignatureDeclaration(...args: Array): Object { return builder("TSCallSignatureDeclaration", ...args); } -export { tsCallSignatureDeclaration as TSCallSignatureDeclaration }; -export { tsCallSignatureDeclaration as tSCallSignatureDeclaration }; -export function tsConstructSignatureDeclaration(...args: Array): Object { +export { TSCallSignatureDeclaration as tsCallSignatureDeclaration }; +export function TSConstructSignatureDeclaration(...args: Array): Object { return builder("TSConstructSignatureDeclaration", ...args); } -export { tsConstructSignatureDeclaration as TSConstructSignatureDeclaration }; -export { tsConstructSignatureDeclaration as tSConstructSignatureDeclaration }; -export function tsPropertySignature(...args: Array): Object { +export { TSConstructSignatureDeclaration as tsConstructSignatureDeclaration }; +export function TSPropertySignature(...args: Array): Object { return builder("TSPropertySignature", ...args); } -export { tsPropertySignature as TSPropertySignature }; -export { tsPropertySignature as tSPropertySignature }; -export function tsMethodSignature(...args: Array): Object { +export { TSPropertySignature as tsPropertySignature }; +export function TSMethodSignature(...args: Array): Object { return builder("TSMethodSignature", ...args); } -export { tsMethodSignature as TSMethodSignature }; -export { tsMethodSignature as tSMethodSignature }; -export function tsIndexSignature(...args: Array): Object { +export { TSMethodSignature as tsMethodSignature }; +export function TSIndexSignature(...args: Array): Object { return builder("TSIndexSignature", ...args); } -export { tsIndexSignature as TSIndexSignature }; -export { tsIndexSignature as tSIndexSignature }; -export function tsAnyKeyword(...args: Array): Object { +export { TSIndexSignature as tsIndexSignature }; +export function TSAnyKeyword(...args: Array): Object { return builder("TSAnyKeyword", ...args); } -export { tsAnyKeyword as TSAnyKeyword }; -export { tsAnyKeyword as tSAnyKeyword }; -export function tsBooleanKeyword(...args: Array): Object { +export { TSAnyKeyword as tsAnyKeyword }; +export function TSBooleanKeyword(...args: Array): Object { return builder("TSBooleanKeyword", ...args); } -export { tsBooleanKeyword as TSBooleanKeyword }; -export { tsBooleanKeyword as tSBooleanKeyword }; -export function tsBigIntKeyword(...args: Array): Object { +export { TSBooleanKeyword as tsBooleanKeyword }; +export function TSBigIntKeyword(...args: Array): Object { return builder("TSBigIntKeyword", ...args); } -export { tsBigIntKeyword as TSBigIntKeyword }; -export { tsBigIntKeyword as tSBigIntKeyword }; -export function tsIntrinsicKeyword(...args: Array): Object { +export { TSBigIntKeyword as tsBigIntKeyword }; +export function TSIntrinsicKeyword(...args: Array): Object { return builder("TSIntrinsicKeyword", ...args); } -export { tsIntrinsicKeyword as TSIntrinsicKeyword }; -export { tsIntrinsicKeyword as tSIntrinsicKeyword }; -export function tsNeverKeyword(...args: Array): Object { +export { TSIntrinsicKeyword as tsIntrinsicKeyword }; +export function TSNeverKeyword(...args: Array): Object { return builder("TSNeverKeyword", ...args); } -export { tsNeverKeyword as TSNeverKeyword }; -export { tsNeverKeyword as tSNeverKeyword }; -export function tsNullKeyword(...args: Array): Object { +export { TSNeverKeyword as tsNeverKeyword }; +export function TSNullKeyword(...args: Array): Object { return builder("TSNullKeyword", ...args); } -export { tsNullKeyword as TSNullKeyword }; -export { tsNullKeyword as tSNullKeyword }; -export function tsNumberKeyword(...args: Array): Object { +export { TSNullKeyword as tsNullKeyword }; +export function TSNumberKeyword(...args: Array): Object { return builder("TSNumberKeyword", ...args); } -export { tsNumberKeyword as TSNumberKeyword }; -export { tsNumberKeyword as tSNumberKeyword }; -export function tsObjectKeyword(...args: Array): Object { +export { TSNumberKeyword as tsNumberKeyword }; +export function TSObjectKeyword(...args: Array): Object { return builder("TSObjectKeyword", ...args); } -export { tsObjectKeyword as TSObjectKeyword }; -export { tsObjectKeyword as tSObjectKeyword }; -export function tsStringKeyword(...args: Array): Object { +export { TSObjectKeyword as tsObjectKeyword }; +export function TSStringKeyword(...args: Array): Object { return builder("TSStringKeyword", ...args); } -export { tsStringKeyword as TSStringKeyword }; -export { tsStringKeyword as tSStringKeyword }; -export function tsSymbolKeyword(...args: Array): Object { +export { TSStringKeyword as tsStringKeyword }; +export function TSSymbolKeyword(...args: Array): Object { return builder("TSSymbolKeyword", ...args); } -export { tsSymbolKeyword as TSSymbolKeyword }; -export { tsSymbolKeyword as tSSymbolKeyword }; -export function tsUndefinedKeyword(...args: Array): Object { +export { TSSymbolKeyword as tsSymbolKeyword }; +export function TSUndefinedKeyword(...args: Array): Object { return builder("TSUndefinedKeyword", ...args); } -export { tsUndefinedKeyword as TSUndefinedKeyword }; -export { tsUndefinedKeyword as tSUndefinedKeyword }; -export function tsUnknownKeyword(...args: Array): Object { +export { TSUndefinedKeyword as tsUndefinedKeyword }; +export function TSUnknownKeyword(...args: Array): Object { return builder("TSUnknownKeyword", ...args); } -export { tsUnknownKeyword as TSUnknownKeyword }; -export { tsUnknownKeyword as tSUnknownKeyword }; -export function tsVoidKeyword(...args: Array): Object { +export { TSUnknownKeyword as tsUnknownKeyword }; +export function TSVoidKeyword(...args: Array): Object { return builder("TSVoidKeyword", ...args); } -export { tsVoidKeyword as TSVoidKeyword }; -export { tsVoidKeyword as tSVoidKeyword }; -export function tsThisType(...args: Array): Object { +export { TSVoidKeyword as tsVoidKeyword }; +export function TSThisType(...args: Array): Object { return builder("TSThisType", ...args); } -export { tsThisType as TSThisType }; -export { tsThisType as tSThisType }; -export function tsFunctionType(...args: Array): Object { +export { TSThisType as tsThisType }; +export function TSFunctionType(...args: Array): Object { return builder("TSFunctionType", ...args); } -export { tsFunctionType as TSFunctionType }; -export { tsFunctionType as tSFunctionType }; -export function tsConstructorType(...args: Array): Object { +export { TSFunctionType as tsFunctionType }; +export function TSConstructorType(...args: Array): Object { return builder("TSConstructorType", ...args); } -export { tsConstructorType as TSConstructorType }; -export { tsConstructorType as tSConstructorType }; -export function tsTypeReference(...args: Array): Object { +export { TSConstructorType as tsConstructorType }; +export function TSTypeReference(...args: Array): Object { return builder("TSTypeReference", ...args); } -export { tsTypeReference as TSTypeReference }; -export { tsTypeReference as tSTypeReference }; -export function tsTypePredicate(...args: Array): Object { +export { TSTypeReference as tsTypeReference }; +export function TSTypePredicate(...args: Array): Object { return builder("TSTypePredicate", ...args); } -export { tsTypePredicate as TSTypePredicate }; -export { tsTypePredicate as tSTypePredicate }; -export function tsTypeQuery(...args: Array): Object { +export { TSTypePredicate as tsTypePredicate }; +export function TSTypeQuery(...args: Array): Object { return builder("TSTypeQuery", ...args); } -export { tsTypeQuery as TSTypeQuery }; -export { tsTypeQuery as tSTypeQuery }; -export function tsTypeLiteral(...args: Array): Object { +export { TSTypeQuery as tsTypeQuery }; +export function TSTypeLiteral(...args: Array): Object { return builder("TSTypeLiteral", ...args); } -export { tsTypeLiteral as TSTypeLiteral }; -export { tsTypeLiteral as tSTypeLiteral }; -export function tsArrayType(...args: Array): Object { +export { TSTypeLiteral as tsTypeLiteral }; +export function TSArrayType(...args: Array): Object { return builder("TSArrayType", ...args); } -export { tsArrayType as TSArrayType }; -export { tsArrayType as tSArrayType }; -export function tsTupleType(...args: Array): Object { +export { TSArrayType as tsArrayType }; +export function TSTupleType(...args: Array): Object { return builder("TSTupleType", ...args); } -export { tsTupleType as TSTupleType }; -export { tsTupleType as tSTupleType }; -export function tsOptionalType(...args: Array): Object { +export { TSTupleType as tsTupleType }; +export function TSOptionalType(...args: Array): Object { return builder("TSOptionalType", ...args); } -export { tsOptionalType as TSOptionalType }; -export { tsOptionalType as tSOptionalType }; -export function tsRestType(...args: Array): Object { +export { TSOptionalType as tsOptionalType }; +export function TSRestType(...args: Array): Object { return builder("TSRestType", ...args); } -export { tsRestType as TSRestType }; -export { tsRestType as tSRestType }; -export function tsNamedTupleMember(...args: Array): Object { +export { TSRestType as tsRestType }; +export function TSNamedTupleMember(...args: Array): Object { return builder("TSNamedTupleMember", ...args); } -export { tsNamedTupleMember as TSNamedTupleMember }; -export { tsNamedTupleMember as tSNamedTupleMember }; -export function tsUnionType(...args: Array): Object { +export { TSNamedTupleMember as tsNamedTupleMember }; +export function TSUnionType(...args: Array): Object { return builder("TSUnionType", ...args); } -export { tsUnionType as TSUnionType }; -export { tsUnionType as tSUnionType }; -export function tsIntersectionType(...args: Array): Object { +export { TSUnionType as tsUnionType }; +export function TSIntersectionType(...args: Array): Object { return builder("TSIntersectionType", ...args); } -export { tsIntersectionType as TSIntersectionType }; -export { tsIntersectionType as tSIntersectionType }; -export function tsConditionalType(...args: Array): Object { +export { TSIntersectionType as tsIntersectionType }; +export function TSConditionalType(...args: Array): Object { return builder("TSConditionalType", ...args); } -export { tsConditionalType as TSConditionalType }; -export { tsConditionalType as tSConditionalType }; -export function tsInferType(...args: Array): Object { +export { TSConditionalType as tsConditionalType }; +export function TSInferType(...args: Array): Object { return builder("TSInferType", ...args); } -export { tsInferType as TSInferType }; -export { tsInferType as tSInferType }; -export function tsParenthesizedType(...args: Array): Object { +export { TSInferType as tsInferType }; +export function TSParenthesizedType(...args: Array): Object { return builder("TSParenthesizedType", ...args); } -export { tsParenthesizedType as TSParenthesizedType }; -export { tsParenthesizedType as tSParenthesizedType }; -export function tsTypeOperator(...args: Array): Object { +export { TSParenthesizedType as tsParenthesizedType }; +export function TSTypeOperator(...args: Array): Object { return builder("TSTypeOperator", ...args); } -export { tsTypeOperator as TSTypeOperator }; -export { tsTypeOperator as tSTypeOperator }; -export function tsIndexedAccessType(...args: Array): Object { +export { TSTypeOperator as tsTypeOperator }; +export function TSIndexedAccessType(...args: Array): Object { return builder("TSIndexedAccessType", ...args); } -export { tsIndexedAccessType as TSIndexedAccessType }; -export { tsIndexedAccessType as tSIndexedAccessType }; -export function tsMappedType(...args: Array): Object { +export { TSIndexedAccessType as tsIndexedAccessType }; +export function TSMappedType(...args: Array): Object { return builder("TSMappedType", ...args); } -export { tsMappedType as TSMappedType }; -export { tsMappedType as tSMappedType }; -export function tsLiteralType(...args: Array): Object { +export { TSMappedType as tsMappedType }; +export function TSLiteralType(...args: Array): Object { return builder("TSLiteralType", ...args); } -export { tsLiteralType as TSLiteralType }; -export { tsLiteralType as tSLiteralType }; -export function tsExpressionWithTypeArguments(...args: Array): Object { +export { TSLiteralType as tsLiteralType }; +export function TSExpressionWithTypeArguments(...args: Array): Object { return builder("TSExpressionWithTypeArguments", ...args); } -export { tsExpressionWithTypeArguments as TSExpressionWithTypeArguments }; -export { tsExpressionWithTypeArguments as tSExpressionWithTypeArguments }; -export function tsInterfaceDeclaration(...args: Array): Object { +export { TSExpressionWithTypeArguments as tsExpressionWithTypeArguments }; +export function TSInterfaceDeclaration(...args: Array): Object { return builder("TSInterfaceDeclaration", ...args); } -export { tsInterfaceDeclaration as TSInterfaceDeclaration }; -export { tsInterfaceDeclaration as tSInterfaceDeclaration }; -export function tsInterfaceBody(...args: Array): Object { +export { TSInterfaceDeclaration as tsInterfaceDeclaration }; +export function TSInterfaceBody(...args: Array): Object { return builder("TSInterfaceBody", ...args); } -export { tsInterfaceBody as TSInterfaceBody }; -export { tsInterfaceBody as tSInterfaceBody }; -export function tsTypeAliasDeclaration(...args: Array): Object { +export { TSInterfaceBody as tsInterfaceBody }; +export function TSTypeAliasDeclaration(...args: Array): Object { return builder("TSTypeAliasDeclaration", ...args); } -export { tsTypeAliasDeclaration as TSTypeAliasDeclaration }; -export { tsTypeAliasDeclaration as tSTypeAliasDeclaration }; -export function tsAsExpression(...args: Array): Object { +export { TSTypeAliasDeclaration as tsTypeAliasDeclaration }; +export function TSAsExpression(...args: Array): Object { return builder("TSAsExpression", ...args); } -export { tsAsExpression as TSAsExpression }; -export { tsAsExpression as tSAsExpression }; -export function tsTypeAssertion(...args: Array): Object { +export { TSAsExpression as tsAsExpression }; +export function TSTypeAssertion(...args: Array): Object { return builder("TSTypeAssertion", ...args); } -export { tsTypeAssertion as TSTypeAssertion }; -export { tsTypeAssertion as tSTypeAssertion }; -export function tsEnumDeclaration(...args: Array): Object { +export { TSTypeAssertion as tsTypeAssertion }; +export function TSEnumDeclaration(...args: Array): Object { return builder("TSEnumDeclaration", ...args); } -export { tsEnumDeclaration as TSEnumDeclaration }; -export { tsEnumDeclaration as tSEnumDeclaration }; -export function tsEnumMember(...args: Array): Object { +export { TSEnumDeclaration as tsEnumDeclaration }; +export function TSEnumMember(...args: Array): Object { return builder("TSEnumMember", ...args); } -export { tsEnumMember as TSEnumMember }; -export { tsEnumMember as tSEnumMember }; -export function tsModuleDeclaration(...args: Array): Object { +export { TSEnumMember as tsEnumMember }; +export function TSModuleDeclaration(...args: Array): Object { return builder("TSModuleDeclaration", ...args); } -export { tsModuleDeclaration as TSModuleDeclaration }; -export { tsModuleDeclaration as tSModuleDeclaration }; -export function tsModuleBlock(...args: Array): Object { +export { TSModuleDeclaration as tsModuleDeclaration }; +export function TSModuleBlock(...args: Array): Object { return builder("TSModuleBlock", ...args); } -export { tsModuleBlock as TSModuleBlock }; -export { tsModuleBlock as tSModuleBlock }; -export function tsImportType(...args: Array): Object { +export { TSModuleBlock as tsModuleBlock }; +export function TSImportType(...args: Array): Object { return builder("TSImportType", ...args); } -export { tsImportType as TSImportType }; -export { tsImportType as tSImportType }; -export function tsImportEqualsDeclaration(...args: Array): Object { +export { TSImportType as tsImportType }; +export function TSImportEqualsDeclaration(...args: Array): Object { return builder("TSImportEqualsDeclaration", ...args); } -export { tsImportEqualsDeclaration as TSImportEqualsDeclaration }; -export { tsImportEqualsDeclaration as tSImportEqualsDeclaration }; -export function tsExternalModuleReference(...args: Array): Object { +export { TSImportEqualsDeclaration as tsImportEqualsDeclaration }; +export function TSExternalModuleReference(...args: Array): Object { return builder("TSExternalModuleReference", ...args); } -export { tsExternalModuleReference as TSExternalModuleReference }; -export { tsExternalModuleReference as tSExternalModuleReference }; -export function tsNonNullExpression(...args: Array): Object { +export { TSExternalModuleReference as tsExternalModuleReference }; +export function TSNonNullExpression(...args: Array): Object { return builder("TSNonNullExpression", ...args); } -export { tsNonNullExpression as TSNonNullExpression }; -export { tsNonNullExpression as tSNonNullExpression }; -export function tsExportAssignment(...args: Array): Object { +export { TSNonNullExpression as tsNonNullExpression }; +export function TSExportAssignment(...args: Array): Object { return builder("TSExportAssignment", ...args); } -export { tsExportAssignment as TSExportAssignment }; -export { tsExportAssignment as tSExportAssignment }; -export function tsNamespaceExportDeclaration(...args: Array): Object { +export { TSExportAssignment as tsExportAssignment }; +export function TSNamespaceExportDeclaration(...args: Array): Object { return builder("TSNamespaceExportDeclaration", ...args); } -export { tsNamespaceExportDeclaration as TSNamespaceExportDeclaration }; -export { tsNamespaceExportDeclaration as tSNamespaceExportDeclaration }; -export function tsTypeAnnotation(...args: Array): Object { +export { TSNamespaceExportDeclaration as tsNamespaceExportDeclaration }; +export function TSTypeAnnotation(...args: Array): Object { return builder("TSTypeAnnotation", ...args); } -export { tsTypeAnnotation as TSTypeAnnotation }; -export { tsTypeAnnotation as tSTypeAnnotation }; -export function tsTypeParameterInstantiation(...args: Array): Object { +export { TSTypeAnnotation as tsTypeAnnotation }; +export function TSTypeParameterInstantiation(...args: Array): Object { return builder("TSTypeParameterInstantiation", ...args); } -export { tsTypeParameterInstantiation as TSTypeParameterInstantiation }; -export { tsTypeParameterInstantiation as tSTypeParameterInstantiation }; -export function tsTypeParameterDeclaration(...args: Array): Object { +export { TSTypeParameterInstantiation as tsTypeParameterInstantiation }; +export function TSTypeParameterDeclaration(...args: Array): Object { return builder("TSTypeParameterDeclaration", ...args); } -export { tsTypeParameterDeclaration as TSTypeParameterDeclaration }; -export { tsTypeParameterDeclaration as tSTypeParameterDeclaration }; -export function tsTypeParameter(...args: Array): Object { +export { TSTypeParameterDeclaration as tsTypeParameterDeclaration }; +export function TSTypeParameter(...args: Array): Object { return builder("TSTypeParameter", ...args); } -export { tsTypeParameter as TSTypeParameter }; -export { tsTypeParameter as tSTypeParameter }; +export { TSTypeParameter as tsTypeParameter }; export function NumberLiteral(...args: Array): Object { console.trace( "The node type NumberLiteral has been renamed to NumericLiteral", diff --git a/packages/babel-types/src/definitions/core.js b/packages/babel-types/src/definitions/core.js index 13deeab880ca..d0eeed92acd8 100644 --- a/packages/babel-types/src/definitions/core.js +++ b/packages/babel-types/src/definitions/core.js @@ -33,7 +33,6 @@ defineType("ArrayExpression", { assertNodeOrValueType("null", "Expression", "SpreadElement"), ), ), - default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined, }, }, visitor: ["elements"], @@ -44,10 +43,6 @@ defineType("AssignmentExpression", { fields: { operator: { validate: (function () { - if (!process.env.BABEL_TYPES_8_BREAKING) { - return assertValueType("string"); - } - const identifier = assertOneOf(...ASSIGNMENT_OPERATORS); const pattern = assertOneOf("="); @@ -58,14 +53,12 @@ defineType("AssignmentExpression", { })(), }, left: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? assertNodeType("LVal") - : assertNodeType( - "Identifier", - "MemberExpression", - "ArrayPattern", - "ObjectPattern", - ), + validate: assertNodeType( + "Identifier", + "MemberExpression", + "ArrayPattern", + "ObjectPattern", + ), }, right: { validate: assertNodeType("Expression"), @@ -184,14 +177,6 @@ defineType("CallExpression", { ), ), }, - ...(!process.env.BABEL_TYPES_8_BREAKING - ? { - optional: { - validate: assertOneOf(true, false), - optional: true, - }, - } - : {}), typeArguments: { validate: assertNodeType("TypeParameterInstantiation"), optional: true, @@ -283,11 +268,7 @@ defineType("File", { validate: assertNodeType("Program"), }, comments: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? Object.assign(() => {}, { - each: { oneOfNodeTypes: ["CommentBlock", "CommentLine"] }, - }) - : assertEach(assertNodeType("CommentBlock", "CommentLine")), + validate: assertEach(assertNodeType("CommentBlock", "CommentLine")), optional: true, }, tokens: { @@ -310,15 +291,13 @@ defineType("ForInStatement", { ], fields: { left: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? assertNodeType("VariableDeclaration", "LVal") - : assertNodeType( - "VariableDeclaration", - "Identifier", - "MemberExpression", - "ArrayPattern", - "ObjectPattern", - ), + validate: assertNodeType( + "VariableDeclaration", + "Identifier", + "MemberExpression", + "ArrayPattern", + "ObjectPattern", + ), }, right: { validate: assertNodeType("Expression"), @@ -420,8 +399,6 @@ defineType("FunctionDeclaration", { "Declaration", ], validate: (function () { - if (!process.env.BABEL_TYPES_8_BREAKING) return () => {}; - const identifier = assertNodeType("Identifier"); return function (parent, key, node) { @@ -480,8 +457,6 @@ defineType("Identifier", { assertValueType("string"), Object.assign( function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - if (!isValidIdentifier(val, false)) { throw new TypeError(`"${val}" is not a valid identifier name`); } @@ -496,8 +471,6 @@ defineType("Identifier", { }, }, validate(parent, key, node) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - const match = /\.(\w+)$/.exec(key); if (!match) return; @@ -612,8 +585,6 @@ defineType("RegExpLiteral", { assertValueType("string"), Object.assign( function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - const invalid = /[^gimsuy]/.exec(val); if (invalid) { throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`); @@ -669,14 +640,6 @@ defineType("MemberExpression", { computed: { default: false, }, - ...(!process.env.BABEL_TYPES_8_BREAKING - ? { - optional: { - validate: assertOneOf(true, false), - optional: true, - }, - } - : {}), }, }); @@ -739,7 +702,6 @@ defineType("ObjectMethod", { ...functionTypeAnnotationCommon, kind: { validate: assertOneOf("method", "get", "set"), - ...(!process.env.BABEL_TYPES_8_BREAKING ? { default: "method" } : {}), }, computed: { default: false, @@ -798,13 +760,7 @@ defineType("ObjectMethod", { }); defineType("ObjectProperty", { - builder: [ - "key", - "value", - "computed", - "shorthand", - ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : []), - ], + builder: ["key", "value", "computed", "shorthand"], fields: { computed: { default: false, @@ -842,8 +798,6 @@ defineType("ObjectProperty", { assertValueType("boolean"), Object.assign( function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - if (val && node.computed) { throw new TypeError( "Property shorthand of ObjectProperty cannot be true if computed is true", @@ -852,15 +806,6 @@ defineType("ObjectProperty", { }, { type: "boolean" }, ), - function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - - if (val && !is("Identifier", node.key)) { - throw new TypeError( - "Property shorthand of ObjectProperty cannot be true if key is not an Identifier", - ); - } - }, ), default: false, }, @@ -879,8 +824,6 @@ defineType("ObjectProperty", { const expression = assertNodeType("Expression"); return function (parent, key, node) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - const validator = is("ObjectPattern", parent) ? pattern : expression; validator(node, "value", node.value); }; @@ -895,14 +838,10 @@ defineType("RestElement", { fields: { ...patternLikeCommon, argument: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? assertNodeType("LVal") - : assertNodeType("Identifier", "Pattern", "MemberExpression"), + validate: assertNodeType("Identifier", "Pattern", "MemberExpression"), }, }, validate(parent, key) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - const match = /(\w+)\[(\d+)\]/.exec(key); if (!match) throw new Error("Internal Babel error: malformed key."); @@ -1002,8 +941,6 @@ defineType("TryStatement", { assertNodeType("BlockStatement"), Object.assign( function (node) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - // This validator isn't put at the top level because we can run it // even if this node doesn't have a parent. @@ -1054,9 +991,7 @@ defineType("UpdateExpression", { default: false, }, argument: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? assertNodeType("Expression") - : assertNodeType("Identifier", "MemberExpression"), + validate: assertNodeType("Identifier", "MemberExpression"), }, operator: { validate: assertOneOf(...UPDATE_OPERATORS), @@ -1086,8 +1021,6 @@ defineType("VariableDeclaration", { }, }, validate(parent, key, node) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - if (!is("ForXStatement", parent, { left: node })) return; if (node.declarations.length !== 1) { throw new TypeError( @@ -1102,10 +1035,6 @@ defineType("VariableDeclarator", { fields: { id: { validate: (function () { - if (!process.env.BABEL_TYPES_8_BREAKING) { - return assertNodeType("LVal"); - } - const normal = assertNodeType( "Identifier", "ArrayPattern", @@ -1380,8 +1309,6 @@ defineType("ClassDeclaration", { const identifier = assertNodeType("Identifier"); return function (parent, key, node) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - if (!is("ExportDefaultDeclaration", parent)) { identifier(node, "id", node.id); } @@ -1446,8 +1373,6 @@ defineType("ExportNamedDeclaration", { assertNodeType("Declaration"), Object.assign( function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - // This validator isn't put at the top level because we can run it // even if this node doesn't have a parent. @@ -1460,8 +1385,6 @@ defineType("ExportNamedDeclaration", { { oneOfNodeTypes: ["Declaration"] }, ), function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - // This validator isn't put at the top level because we can run it // even if this node doesn't have a parent. @@ -1491,8 +1414,6 @@ defineType("ExportNamedDeclaration", { ); const sourceless = assertNodeType("ExportSpecifier"); - if (!process.env.BABEL_TYPES_8_BREAKING) return sourced; - return function (node, key, val) { const validator = node.source ? sourced : sourceless; validator(node, key, val); @@ -1536,10 +1457,6 @@ defineType("ForOfStatement", { fields: { left: { validate: (function () { - if (!process.env.BABEL_TYPES_8_BREAKING) { - return assertNodeType("VariableDeclaration", "LVal"); - } - const declaration = assertNodeType("VariableDeclaration"); const lval = assertNodeType( "Identifier", @@ -1651,8 +1568,6 @@ defineType("MetaProperty", { assertNodeType("Identifier"), Object.assign( function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - let property; switch (val.name) { case "function": @@ -1895,8 +1810,6 @@ defineType("YieldExpression", { assertValueType("boolean"), Object.assign( function (node, key, val) { - if (!process.env.BABEL_TYPES_8_BREAKING) return; - if (val && !node.argument) { throw new TypeError( "Property delegate of YieldExpression cannot be true if there is no argument", @@ -1979,9 +1892,7 @@ defineType("OptionalMemberExpression", { default: false, }, optional: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? assertValueType("boolean") - : chain(assertValueType("boolean"), assertOptionalChainStart()), + validate: chain(assertValueType("boolean"), assertOptionalChainStart()), }, }, }); @@ -2003,9 +1914,7 @@ defineType("OptionalCallExpression", { ), }, optional: { - validate: !process.env.BABEL_TYPES_8_BREAKING - ? assertValueType("boolean") - : chain(assertValueType("boolean"), assertOptionalChainStart()), + validate: chain(assertValueType("boolean"), assertOptionalChainStart()), }, typeArguments: { validate: assertNodeType("TypeParameterInstantiation"), diff --git a/packages/babel-types/src/definitions/es2015.js b/packages/babel-types/src/definitions/es2015.js new file mode 100644 index 000000000000..7223a7085d14 --- /dev/null +++ b/packages/babel-types/src/definitions/es2015.js @@ -0,0 +1,728 @@ +// @flow +import defineType, { + assertShape, + assertNodeType, + assertValueType, + assertNodeOrValueType, + chain, + assertEach, + assertOneOf, + validateOptional, +} from "./utils"; +import { + functionCommon, + functionTypeAnnotationCommon, + patternLikeCommon, +} from "./core"; +import is from "../validators/is"; + +defineType("AssignmentPattern", { + visitor: ["left", "right", "decorators" /* for legacy param decorators */], + builder: ["left", "right"], + aliases: ["Pattern", "PatternLike", "LVal"], + fields: { + ...patternLikeCommon, + left: { + validate: assertNodeType( + "Identifier", + "ObjectPattern", + "ArrayPattern", + "MemberExpression", + ), + }, + right: { + validate: assertNodeType("Expression"), + }, + // For TypeScript + decorators: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("Decorator")), + ), + optional: true, + }, + }, +}); + +defineType("ArrayPattern", { + visitor: ["elements", "typeAnnotation"], + builder: ["elements"], + aliases: ["Pattern", "PatternLike", "LVal"], + fields: { + ...patternLikeCommon, + elements: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeOrValueType("null", "PatternLike")), + ), + }, + // For TypeScript + decorators: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("Decorator")), + ), + optional: true, + }, + }, +}); + +defineType("ArrowFunctionExpression", { + builder: ["params", "body", "async"], + visitor: ["params", "body", "returnType", "typeParameters"], + aliases: [ + "Scopable", + "Function", + "BlockParent", + "FunctionParent", + "Expression", + "Pureish", + ], + fields: { + ...functionCommon, + ...functionTypeAnnotationCommon, + expression: { + // https://github.com/babel/babylon/issues/505 + validate: assertValueType("boolean"), + }, + body: { + validate: assertNodeType("BlockStatement", "Expression"), + }, + }, +}); + +defineType("ClassBody", { + visitor: ["body"], + fields: { + body: { + validate: chain( + assertValueType("array"), + assertEach( + assertNodeType( + "ClassMethod", + "ClassPrivateMethod", + "ClassProperty", + "ClassPrivateProperty", + "TSDeclareMethod", + "TSIndexSignature", + ), + ), + ), + }, + }, +}); + +defineType("ClassExpression", { + builder: ["id", "superClass", "body", "decorators"], + visitor: [ + "id", + "body", + "superClass", + "mixins", + "typeParameters", + "superTypeParameters", + "implements", + "decorators", + ], + aliases: ["Scopable", "Class", "Expression"], + fields: { + id: { + validate: assertNodeType("Identifier"), + // In declarations, this is missing if this is the + // child of an ExportDefaultDeclaration. + optional: true, + }, + typeParameters: { + validate: assertNodeType( + "TypeParameterDeclaration", + "TSTypeParameterDeclaration", + "Noop", + ), + optional: true, + }, + body: { + validate: assertNodeType("ClassBody"), + }, + superClass: { + optional: true, + validate: assertNodeType("Expression"), + }, + superTypeParameters: { + validate: assertNodeType( + "TypeParameterInstantiation", + "TSTypeParameterInstantiation", + ), + optional: true, + }, + implements: { + validate: chain( + assertValueType("array"), + assertEach( + assertNodeType("TSExpressionWithTypeArguments", "ClassImplements"), + ), + ), + optional: true, + }, + decorators: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("Decorator")), + ), + optional: true, + }, + mixins: { + validate: assertNodeType("InterfaceExtends"), + optional: true, + }, + }, +}); + +defineType("ClassDeclaration", { + inherits: "ClassExpression", + aliases: ["Scopable", "Class", "Statement", "Declaration"], + fields: { + id: { + validate: assertNodeType("Identifier"), + }, + typeParameters: { + validate: assertNodeType( + "TypeParameterDeclaration", + "TSTypeParameterDeclaration", + "Noop", + ), + optional: true, + }, + body: { + validate: assertNodeType("ClassBody"), + }, + superClass: { + optional: true, + validate: assertNodeType("Expression"), + }, + superTypeParameters: { + validate: assertNodeType( + "TypeParameterInstantiation", + "TSTypeParameterInstantiation", + ), + optional: true, + }, + implements: { + validate: chain( + assertValueType("array"), + assertEach( + assertNodeType("TSExpressionWithTypeArguments", "ClassImplements"), + ), + ), + optional: true, + }, + decorators: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("Decorator")), + ), + optional: true, + }, + mixins: { + validate: assertNodeType("InterfaceExtends"), + optional: true, + }, + declare: { + validate: assertValueType("boolean"), + optional: true, + }, + abstract: { + validate: assertValueType("boolean"), + optional: true, + }, + }, + validate: (function () { + const identifier = assertNodeType("Identifier"); + + return function (parent, key, node) { + if (!is("ExportDefaultDeclaration", parent)) { + identifier(node, "id", node.id); + } + }; + })(), +}); + +defineType("ExportAllDeclaration", { + visitor: ["source"], + aliases: [ + "Statement", + "Declaration", + "ModuleDeclaration", + "ExportDeclaration", + ], + fields: { + source: { + validate: assertNodeType("StringLiteral"), + }, + }, +}); + +defineType("ExportDefaultDeclaration", { + visitor: ["declaration"], + aliases: [ + "Statement", + "Declaration", + "ModuleDeclaration", + "ExportDeclaration", + ], + fields: { + declaration: { + validate: assertNodeType( + "FunctionDeclaration", + "TSDeclareFunction", + "ClassDeclaration", + "Expression", + ), + }, + }, +}); + +defineType("ExportNamedDeclaration", { + visitor: ["declaration", "specifiers", "source"], + aliases: [ + "Statement", + "Declaration", + "ModuleDeclaration", + "ExportDeclaration", + ], + fields: { + declaration: { + optional: true, + validate: chain( + assertNodeType("Declaration"), + Object.assign( + function (node, key, val) { + // This validator isn't put at the top level because we can run it + // even if this node doesn't have a parent. + + if (val && node.specifiers.length) { + throw new TypeError( + "Only declaration or specifiers is allowed on ExportNamedDeclaration", + ); + } + + if (val && node.source) { + throw new TypeError("Cannot export a declaration from a source"); + } + }, + { oneOfNodeTypes: ["Declaration"] }, + ), + ), + }, + specifiers: { + default: [], + validate: chain( + assertValueType("array"), + assertEach( + (function () { + const sourced = assertNodeType( + "ExportSpecifier", + "ExportDefaultSpecifier", + "ExportNamespaceSpecifier", + ); + const sourceless = assertNodeType("ExportSpecifier"); + + return function (node, key, val) { + const validator = node.source ? sourced : sourceless; + validator(node, key, val); + }; + })(), + ), + ), + }, + source: { + validate: assertNodeType("StringLiteral"), + optional: true, + }, + exportKind: validateOptional(assertOneOf("type", "value")), + }, +}); + +defineType("ExportSpecifier", { + visitor: ["local", "exported"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: assertNodeType("Identifier"), + }, + exported: { + validate: assertNodeType("Identifier"), + }, + }, +}); + +defineType("ForOfStatement", { + visitor: ["left", "right", "body"], + builder: ["left", "right", "body", "await"], + aliases: [ + "Scopable", + "Statement", + "For", + "BlockParent", + "Loop", + "ForXStatement", + ], + fields: { + left: { + validate: (function () { + const declaration = assertNodeType("VariableDeclaration"); + const lval = assertNodeType( + "Identifier", + "MemberExpression", + "ArrayPattern", + "ObjectPattern", + ); + + return function (node, key, val) { + if (is("VariableDeclaration", val)) { + declaration(node, key, val); + } else { + lval(node, key, val); + } + }; + })(), + }, + right: { + validate: assertNodeType("Expression"), + }, + body: { + validate: assertNodeType("Statement"), + }, + await: { + default: false, + }, + }, +}); + +defineType("ImportDeclaration", { + visitor: ["specifiers", "source"], + aliases: ["Statement", "Declaration", "ModuleDeclaration"], + fields: { + specifiers: { + validate: chain( + assertValueType("array"), + assertEach( + assertNodeType( + "ImportSpecifier", + "ImportDefaultSpecifier", + "ImportNamespaceSpecifier", + ), + ), + ), + }, + source: { + validate: assertNodeType("StringLiteral"), + }, + importKind: { + // Handle TypeScript/Flowtype's extension "import type foo from" + // TypeScript doesn't support typeof + validate: assertOneOf("type", "typeof", "value"), + optional: true, + }, + }, +}); + +defineType("ImportDefaultSpecifier", { + visitor: ["local"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: assertNodeType("Identifier"), + }, + }, +}); + +defineType("ImportNamespaceSpecifier", { + visitor: ["local"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: assertNodeType("Identifier"), + }, + }, +}); + +defineType("ImportSpecifier", { + visitor: ["local", "imported"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: assertNodeType("Identifier"), + }, + imported: { + validate: assertNodeType("Identifier"), + }, + importKind: { + // Handle Flowtype's extension "import {typeof foo} from" + validate: assertOneOf("type", "typeof"), + optional: true, + }, + }, +}); + +defineType("MetaProperty", { + visitor: ["meta", "property"], + aliases: ["Expression"], + fields: { + meta: { + validate: chain( + assertNodeType("Identifier"), + Object.assign( + function (node, key, val) { + let property; + switch (val.name) { + case "function": + property = "sent"; + break; + case "new": + property = "target"; + break; + case "import": + property = "meta"; + break; + } + if (!is("Identifier", node.property, { name: property })) { + throw new TypeError("Unrecognised MetaProperty"); + } + }, + { oneOfNodeTypes: ["Identifier"] }, + ), + ), + }, + property: { + validate: assertNodeType("Identifier"), + }, + }, +}); + +export const classMethodOrPropertyCommon = { + abstract: { + validate: assertValueType("boolean"), + optional: true, + }, + accessibility: { + validate: assertOneOf("public", "private", "protected"), + optional: true, + }, + static: { + default: false, + }, + computed: { + default: false, + }, + optional: { + validate: assertValueType("boolean"), + optional: true, + }, + key: { + validate: chain( + (function () { + const normal = assertNodeType( + "Identifier", + "StringLiteral", + "NumericLiteral", + ); + const computed = assertNodeType("Expression"); + + return function (node: Object, key: string, val: any) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }; + })(), + assertNodeType( + "Identifier", + "StringLiteral", + "NumericLiteral", + "Expression", + ), + ), + }, +}; + +export const classMethodOrDeclareMethodCommon = { + ...functionCommon, + ...classMethodOrPropertyCommon, + kind: { + validate: assertOneOf("get", "set", "method", "constructor"), + default: "method", + }, + access: { + validate: chain( + assertValueType("string"), + assertOneOf("public", "private", "protected"), + ), + optional: true, + }, + decorators: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("Decorator")), + ), + optional: true, + }, +}; + +defineType("ClassMethod", { + aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], + builder: [ + "kind", + "key", + "params", + "body", + "computed", + "static", + "generator", + "async", + ], + visitor: [ + "key", + "params", + "body", + "decorators", + "returnType", + "typeParameters", + ], + fields: { + ...classMethodOrDeclareMethodCommon, + ...functionTypeAnnotationCommon, + body: { + validate: assertNodeType("BlockStatement"), + }, + }, +}); + +defineType("ObjectPattern", { + visitor: [ + "properties", + "typeAnnotation", + "decorators" /* for legacy param decorators */, + ], + builder: ["properties"], + aliases: ["Pattern", "PatternLike", "LVal"], + fields: { + ...patternLikeCommon, + properties: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("RestElement", "ObjectProperty")), + ), + }, + }, +}); + +defineType("SpreadElement", { + visitor: ["argument"], + aliases: ["UnaryLike"], + deprecatedAlias: "SpreadProperty", + fields: { + argument: { + validate: assertNodeType("Expression"), + }, + }, +}); + +defineType("Super", { + aliases: ["Expression"], +}); + +defineType("TaggedTemplateExpression", { + visitor: ["tag", "quasi"], + aliases: ["Expression"], + fields: { + tag: { + validate: assertNodeType("Expression"), + }, + quasi: { + validate: assertNodeType("TemplateLiteral"), + }, + typeParameters: { + validate: assertNodeType( + "TypeParameterInstantiation", + "TSTypeParameterInstantiation", + ), + optional: true, + }, + }, +}); + +defineType("TemplateElement", { + builder: ["value", "tail"], + fields: { + value: { + validate: assertShape({ + raw: { + validate: assertValueType("string"), + }, + cooked: { + validate: assertValueType("string"), + optional: true, + }, + }), + }, + tail: { + default: false, + }, + }, +}); + +defineType("TemplateLiteral", { + visitor: ["quasis", "expressions"], + aliases: ["Expression", "Literal"], + fields: { + quasis: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("TemplateElement")), + ), + }, + expressions: { + validate: chain( + assertValueType("array"), + assertEach(assertNodeType("Expression")), + function (node, key, val) { + if (node.quasis.length !== val.length + 1) { + throw new TypeError( + `Number of ${ + node.type + } quasis should be exactly one more than the number of expressions.\nExpected ${ + val.length + 1 + } quasis but got ${node.quasis.length}`, + ); + } + }, + ), + }, + }, +}); + +defineType("YieldExpression", { + builder: ["argument", "delegate"], + visitor: ["argument"], + aliases: ["Expression", "Terminatorless"], + fields: { + delegate: { + validate: chain( + assertValueType("boolean"), + Object.assign( + function (node, key, val) { + if (val && !node.argument) { + throw new TypeError( + "Property delegate of YieldExpression cannot be true if there is no argument", + ); + } + }, + { type: "boolean" }, + ), + ), + default: false, + }, + argument: { + optional: true, + validate: assertNodeType("Expression"), + }, + }, +}); diff --git a/packages/babel-types/src/definitions/experimental.js b/packages/babel-types/src/definitions/experimental.js index b7f3360f98c8..b198c4ec5f57 100644 --- a/packages/babel-types/src/definitions/experimental.js +++ b/packages/babel-types/src/definitions/experimental.js @@ -16,27 +16,14 @@ defineType("ArgumentPlaceholder", {}); defineType("BindExpression", { visitor: ["object", "callee"], aliases: ["Expression"], - fields: !process.env.BABEL_TYPES_8_BREAKING - ? { - object: { - validate: Object.assign(() => {}, { - oneOfNodeTypes: ["Expression"], - }), - }, - callee: { - validate: Object.assign(() => {}, { - oneOfNodeTypes: ["Expression"], - }), - }, - } - : { - object: { - validate: assertNodeType("Expression"), - }, - callee: { - validate: assertNodeType("Expression"), - }, - }, + fields: { + object: { + validate: assertNodeType("Expression"), + }, + callee: { + validate: assertNodeType("Expression"), + }, + }, }); defineType("ClassProperty", { diff --git a/packages/babel-types/src/definitions/utils.js b/packages/babel-types/src/definitions/utils.js index 9404fdbab6c9..a9280b991189 100644 --- a/packages/babel-types/src/definitions/utils.js +++ b/packages/babel-types/src/definitions/utils.js @@ -73,7 +73,7 @@ export function assertEach(callback: Validator): Validator { const subkey = `${key}[${i}]`; const v = val[i]; callback(node, subkey, v); - if (process.env.BABEL_TYPES_8_BREAKING) validateChild(node, subkey, v); + validateChild(node, subkey, v); } } validator.each = callback; diff --git a/packages/babel-types/src/index.js b/packages/babel-types/src/index.js index 7239401fd68f..a7e4a9be3a97 100644 --- a/packages/babel-types/src/index.js +++ b/packages/babel-types/src/index.js @@ -9,7 +9,6 @@ export * from "./asserts/generated"; // builders export { default as createTypeAnnotationBasedOnTypeof } from "./builders/flow/createTypeAnnotationBasedOnTypeof"; -export { default as createUnionTypeAnnotation } from "./builders/flow/createFlowUnionType"; export { default as createFlowUnionType } from "./builders/flow/createFlowUnionType"; export { default as createTSUnionType } from "./builders/typescript/createTSUnionType"; export * from "./builders/generated"; diff --git a/packages/babel-types/test/regressions.js b/packages/babel-types/test/regressions.js deleted file mode 100644 index 04c345ba7e58..000000000000 --- a/packages/babel-types/test/regressions.js +++ /dev/null @@ -1,9 +0,0 @@ -import * as t from "../lib"; - -describe("regressions", () => { - it("jest .toMatchInlineSnapshot used 'Line' for comments", () => { - expect(() => { - t.file(t.program([]), [{ type: "Line" }]); - }).not.toThrow(); - }); -}); diff --git a/scripts/parser-tests/flow/allowlist.txt b/scripts/parser-tests/flow/allowlist.txt index b2d5b21fdd04..0155d9e3df19 100644 --- a/scripts/parser-tests/flow/allowlist.txt +++ b/scripts/parser-tests/flow/allowlist.txt @@ -1,7 +1,5 @@ ES6/modules/export_default_class_implements.js ES6/modules/migrated_0020.js -JSX/invalid_unpaired_gt.js -JSX/invalid_unpaired_rcurly.js JSX_invalid/migrated_0000.js arrow_function/object_return_type.js arrow_function_invalid/migrated_0002.js diff --git a/yarn.lock b/yarn.lock index 396f600fa554..e0480556c954 100644 --- a/yarn.lock +++ b/yarn.lock @@ -39,22 +39,18 @@ __metadata: dependencies: "@babel/core": "workspace:*" "@babel/helper-fixtures": "workspace:*" - "@nicolo-ribaudo/chokidar-2": ^2.1.8 chokidar: ^3.4.0 commander: ^4.0.1 convert-source-map: ^1.1.0 fs-readdir-recursive: ^1.1.0 glob: ^7.0.0 lodash: ^4.17.19 - make-dir: ^2.1.0 rimraf: ^3.0.0 - slash: ^2.0.0 + slash: ^3.0.0 source-map: ^0.5.0 peerDependencies: "@babel/core": ^7.0.0-0 dependenciesMeta: - "@nicolo-ribaudo/chokidar-2": - optional: true chokidar: optional: true bin: @@ -138,10 +134,10 @@ __metadata: "@babel/types": "workspace:^7.12.1" convert-source-map: ^1.7.0 debug: ^4.1.0 + escape-string-regexp: ^4.0.0 gensync: ^1.0.0-beta.1 json5: ^2.1.2 lodash: ^4.17.19 - resolve: ^1.3.2 semver: ^5.4.1 source-map: ^0.5.0 languageName: unknown @@ -251,7 +247,7 @@ __metadata: "@babel/helper-fixtures": "workspace:*" "@babel/parser": "workspace:*" "@babel/types": "workspace:^7.12.1" - jsesc: ^2.5.1 + jsesc: ^3.0.1 source-map: ^0.5.0 languageName: unknown linkType: soft @@ -761,10 +757,10 @@ __metadata: "@babel/helper-fixtures": "workspace:^7.10.5" "@babel/polyfill": "workspace:^7.12.1" babel-check-duplicated-nodes: ^1.0.0 - jest-diff: ^24.8.0 + escape-string-regexp: ^4.0.0 + jest-diff: ^25.1.0 lodash: ^4.17.19 quick-lru: 5.1.0 - resolve: ^1.3.2 source-map: ^0.5.0 languageName: unknown linkType: soft @@ -860,7 +856,7 @@ __metadata: dependencies: "@babel/helper-validator-identifier": "workspace:^7.10.4" chalk: ^2.0.0 - js-tokens: ^4.0.0 + js-tokens: ^6.0.0 strip-ansi: ^4.0.0 languageName: unknown linkType: soft @@ -877,10 +873,7 @@ __metadata: core-js: ^3.2.1 fs-readdir-recursive: ^1.0.0 lodash: ^4.17.19 - make-dir: ^2.1.0 - node-environment-flags: ^1.0.5 regenerator-runtime: ^0.13.4 - resolve: ^1.13.1 rimraf: ^3.0.0 v8flags: ^3.1.1 peerDependencies: @@ -1609,7 +1602,7 @@ __metadata: languageName: node linkType: hard -"@babel/plugin-syntax-jsx@workspace:*, @babel/plugin-syntax-jsx@workspace:^7.12.1, @babel/plugin-syntax-jsx@workspace:packages/babel-plugin-syntax-jsx": +"@babel/plugin-syntax-jsx@workspace:*, @babel/plugin-syntax-jsx@workspace:^7.10.4, @babel/plugin-syntax-jsx@workspace:^7.12.1, @babel/plugin-syntax-jsx@workspace:packages/babel-plugin-syntax-jsx": version: 0.0.0-use.local resolution: "@babel/plugin-syntax-jsx@workspace:packages/babel-plugin-syntax-jsx" dependencies: @@ -1902,7 +1895,7 @@ __metadata: "@babel/helper-plugin-utils": "workspace:^7.10.4" "@babel/helper-replace-supers": "workspace:^7.12.1" "@babel/helper-split-export-declaration": "workspace:^7.10.4" - globals: ^11.1.0 + globals: ^12.3.0 peerDependencies: "@babel/core": ^7.0.0-0 languageName: unknown @@ -2661,8 +2654,6 @@ __metadata: "@babel/runtime-corejs3": "workspace:*" "@babel/template": "workspace:*" "@babel/types": "workspace:*" - make-dir: ^2.1.0 - resolve: ^1.8.1 semver: ^5.5.1 peerDependencies: "@babel/core": ^7.0.0-0 @@ -2799,7 +2790,6 @@ __metadata: "@babel/runtime": "workspace:*" "@babel/runtime-corejs2": "workspace:*" "@babel/runtime-corejs3": "workspace:*" - resolve: ^1.15.0 peerDependencies: "@babel/core": ^7.0.0-0 languageName: unknown @@ -3099,6 +3089,7 @@ __metadata: "@babel/core": "workspace:*" "@babel/helper-plugin-test-runner": "workspace:*" "@babel/helper-plugin-utils": "workspace:^7.10.4" + "@babel/plugin-syntax-jsx": "workspace:^7.10.4" "@babel/plugin-transform-typescript": "workspace:^7.12.1" peerDependencies: "@babel/core": ^7.0.0-0 @@ -3127,9 +3118,9 @@ __metadata: "@babel/core": "workspace:*" "@babel/plugin-transform-modules-commonjs": "workspace:*" browserify: ^16.5.2 + escape-string-regexp: ^4.0.0 find-cache-dir: ^2.0.0 lodash: ^4.17.19 - make-dir: ^2.1.0 pirates: ^4.0.0 source-map-support: ^0.5.16 peerDependencies: @@ -3339,7 +3330,7 @@ __metadata: "@babel/parser": "workspace:^7.12.1" "@babel/types": "workspace:^7.12.1" debug: ^4.1.0 - globals: ^11.1.0 + globals: ^12.3.0 lodash: ^4.17.19 languageName: unknown linkType: soft @@ -3589,14 +3580,15 @@ __metadata: languageName: node linkType: hard -"@jest/types@npm:^24.9.0": - version: 24.9.0 - resolution: "@jest/types@npm:24.9.0" +"@jest/types@npm:^25.5.0": + version: 25.5.0 + resolution: "@jest/types@npm:25.5.0" dependencies: "@types/istanbul-lib-coverage": ^2.0.0 "@types/istanbul-reports": ^1.1.1 - "@types/yargs": ^13.0.0 - checksum: 7cd388ad9d3a6de7e0ca29cbaf34dd9da9f6485d26747fc2ef6732bf06dc98d79519b7f3684b7287bd6d5168c394d8f806dc1343bd3c1b3cdc3e85486a518c63 + "@types/yargs": ^15.0.0 + chalk: ^3.0.0 + checksum: 33ad68320efb297c4bd98975105130e1b4096d631decfc5a093691e24f27fce0410b4a7c5a87b736873271ebc003e48e853529587e584b3152efca572139a4a3 languageName: node linkType: hard @@ -3613,15 +3605,6 @@ __metadata: languageName: node linkType: hard -"@nicolo-ribaudo/chokidar-2@npm:^2.1.8": - version: 2.1.8 - resolution: "@nicolo-ribaudo/chokidar-2@npm:2.1.8" - dependencies: - chokidar: 2.1.8 - checksum: a3528e53052074df562ad776ac1211dc03d41b0c06d90b5472cd60d6e717900e4a987d89cf269c3c031ee35674f369e6ebd2e4846ed19d06e5da8ed1ffecb682 - languageName: node - linkType: hard - "@nodelib/fs.scandir@npm:2.1.3": version: 2.1.3 resolution: "@nodelib/fs.scandir@npm:2.1.3" @@ -3921,6 +3904,13 @@ __metadata: languageName: node linkType: hard +"@types/parse-json@npm:^4.0.0": + version: 4.0.0 + resolution: "@types/parse-json@npm:4.0.0" + checksum: 4a8f720afac47b474d3f2eece312340e72bc31bc9561cda37b596ce2ed218c0099765d302625bb67d659a8452a1f93d514f4863c11c7ebaf65430428687dc426 + languageName: node + linkType: hard + "@types/prettier@npm:^2.0.0": version: 2.1.2 resolution: "@types/prettier@npm:2.1.2" @@ -3951,15 +3941,6 @@ __metadata: languageName: node linkType: hard -"@types/yargs@npm:^13.0.0": - version: 13.0.11 - resolution: "@types/yargs@npm:13.0.11" - dependencies: - "@types/yargs-parser": "*" - checksum: 8592d76c18ae57c25e9eeff29a63c2e0885527014ebd6d76244440d5dc1c6e0cf70753d256d77c09f516b082241e6124c1a83a72c061ee83cf5722d5d52f452f - languageName: node - linkType: hard - "@types/yargs@npm:^15.0.0": version: 15.0.8 resolution: "@types/yargs@npm:15.0.8" @@ -4185,7 +4166,7 @@ __metadata: languageName: node linkType: hard -"ansi-regex@npm:^4.0.0, ansi-regex@npm:^4.1.0": +"ansi-regex@npm:^4.1.0": version: 4.1.0 resolution: "ansi-regex@npm:4.1.0" checksum: 53b6fe447cf92ee59739379de637af6f86b3b8a9537fbfe36a66f946f1d9d34afc3efe664ac31bcc7c3af042d43eabcfcfd3f790316d474bbc7b19a4b1d132dd @@ -4726,7 +4707,7 @@ __metadata: gulp-filter: ^5.1.0 gulp-newer: ^1.0.0 gulp-plumber: ^1.2.1 - husky: ^3.0.0 + husky: ^4.2.3 jest: ^26.6.1 lerna-changelog: ^0.5.0 lint-staged: ^9.2.0 @@ -5261,7 +5242,7 @@ __metadata: languageName: node linkType: hard -"chalk@npm:^2.0.0, chalk@npm:^2.0.1, chalk@npm:^2.4.1, chalk@npm:^2.4.2": +"chalk@npm:^2.0.0, chalk@npm:^2.4.1, chalk@npm:^2.4.2": version: 2.4.2 resolution: "chalk@npm:2.4.2" dependencies: @@ -5272,6 +5253,16 @@ __metadata: languageName: node linkType: hard +"chalk@npm:^3.0.0": + version: 3.0.0 + resolution: "chalk@npm:3.0.0" + dependencies: + ansi-styles: ^4.1.0 + supports-color: ^7.1.0 + checksum: 4018b0c812880da595d0d7b8159939527b72f58d3370e2fdc1a24d9abd460bab851695d7eca014082f110d5702d1221b05493fec430ccce375de907d50cc48c1 + languageName: node + linkType: hard + "chalk@npm:^4.0.0, chalk@npm:^4.1.0": version: 4.1.0 resolution: "chalk@npm:4.1.0" @@ -5296,7 +5287,7 @@ __metadata: languageName: node linkType: hard -"chokidar@npm:2.1.8, chokidar@npm:^2.0.0": +"chokidar@npm:^2.0.0": version: 2.1.8 resolution: "chokidar@npm:2.1.8" dependencies: @@ -5621,6 +5612,13 @@ __metadata: languageName: node linkType: hard +"compare-versions@npm:^3.6.0": + version: 3.6.0 + resolution: "compare-versions@npm:3.6.0" + checksum: 09525264502bda1f6667ad2429eaf5520b543d997e79e7a94b66a5896df8921cdc3a97140dfff75af6c9ba1859c872de1921c3cf8a6c48ed807bbf9f582cf093 + languageName: node + linkType: hard + "component-emitter@npm:^1.2.1": version: 1.3.0 resolution: "component-emitter@npm:1.3.0" @@ -5758,6 +5756,19 @@ __metadata: languageName: node linkType: hard +"cosmiconfig@npm:^6.0.0": + version: 6.0.0 + resolution: "cosmiconfig@npm:6.0.0" + dependencies: + "@types/parse-json": ^4.0.0 + import-fresh: ^3.1.0 + parse-json: ^5.0.0 + path-type: ^4.0.0 + yaml: ^1.7.2 + checksum: bbd6bbaefe15938107da21f2b5f2d5ede75c7ed4bca5af904d91987c59b050ac95f5e786d9021e16959e0119b36174b190f6040a1daf6fddc75361ab123c0d45 + languageName: node + linkType: hard + "create-ecdh@npm:^4.0.0": version: 4.0.3 resolution: "create-ecdh@npm:4.0.3" @@ -6121,10 +6132,10 @@ __metadata: languageName: node linkType: hard -"diff-sequences@npm:^24.9.0": - version: 24.9.0 - resolution: "diff-sequences@npm:24.9.0" - checksum: 049107ba804c3a332fe7edefd1cec8df33a18a99c6af77f88b3b9d22b5ee2e1940dbde23b97f97b0d7250a98f8c488c3ba552ebab54dc75c9542c1e90232d009 +"diff-sequences@npm:^25.2.6": + version: 25.2.6 + resolution: "diff-sequences@npm:25.2.6" + checksum: 332484fc00f6beca726d8dbc13095f6006527002bef936a07b4e6bbec681fbaac484e1a7ea4e9ab0d53e375d1cde9e642c8cce31dfe6329cfdf8f01f26b17505 languageName: node linkType: hard @@ -6324,7 +6335,7 @@ __metadata: languageName: node linkType: hard -"es-abstract@npm:^1.17.0, es-abstract@npm:^1.17.0-next.1, es-abstract@npm:^1.17.5, es-abstract@npm:^1.4.3, es-abstract@npm:^1.5.1": +"es-abstract@npm:^1.17.0, es-abstract@npm:^1.17.0-next.1, es-abstract@npm:^1.17.5, es-abstract@npm:^1.4.3": version: 1.17.6 resolution: "es-abstract@npm:1.17.6" dependencies: @@ -6456,6 +6467,13 @@ __metadata: languageName: node linkType: hard +"escape-string-regexp@npm:^4.0.0": + version: 4.0.0 + resolution: "escape-string-regexp@npm:4.0.0" + checksum: c747be8d5ff7873127e3e0cffe7d2206a37208077fa9c30a3c1bb4f26bebd081c8c24d5fba7a99449f9d20670bea3dc5e1b6098b0f074b099bd38766271a272f + languageName: node + linkType: hard + "escodegen@npm:^1.14.1": version: 1.14.3 resolution: "escodegen@npm:1.14.3" @@ -7122,6 +7140,15 @@ __metadata: languageName: node linkType: hard +"find-versions@npm:^3.2.0": + version: 3.2.0 + resolution: "find-versions@npm:3.2.0" + dependencies: + semver-regex: ^2.0.0 + checksum: 2ddc16b4265184e2b7ab68bfd9d84835178fef4193abd957ebe328e0de98e8ca3b31e2a19201c1c8308e24786faa295aab46c0bc21fa89440e2a1bc8174987f0 + languageName: node + linkType: hard + "findup-sync@npm:^2.0.0": version: 2.0.0 resolution: "findup-sync@npm:2.0.0" @@ -7396,13 +7423,6 @@ fsevents@^1.2.7: languageName: node linkType: hard -"get-stdin@npm:^7.0.0": - version: 7.0.0 - resolution: "get-stdin@npm:7.0.0" - checksum: fff64f163097fa3a2ba40b1e3105125f422554485b43694ab3176e37d775052489f0ad31b1d5f59d3fea6054c917779c2c0346f44f4a44f43d4679a638d52283 - languageName: node - linkType: hard - "get-stream@npm:^4.0.0": version: 4.1.0 resolution: "get-stream@npm:4.1.0" @@ -7534,12 +7554,12 @@ fsevents@^1.2.7: languageName: node linkType: hard -"globals@npm:^12.1.0": - version: 12.3.0 - resolution: "globals@npm:12.3.0" +"globals@npm:^12.1.0, globals@npm:^12.3.0": + version: 12.4.0 + resolution: "globals@npm:12.4.0" dependencies: type-fest: ^0.8.1 - checksum: 9df75e1f0ef801281023a7932d1b12e1a71217dbe9d789f342b41ba9fa70181c85b496ef897577223c7e271a964d092cade1b9058e7a49be6aab0fdc9713a090 + checksum: 0b9764bdeab0bc9762dea8954a0d4c5db029420bd8bf693df9098ce7e045ccaf9b2d259185396fd048b051d42fdc8dc7ab02af62e3dbeb2324a78a05aac8d33c languageName: node linkType: hard @@ -7878,25 +7898,24 @@ fsevents@^1.2.7: languageName: node linkType: hard -"husky@npm:^3.0.0": - version: 3.1.0 - resolution: "husky@npm:3.1.0" +"husky@npm:^4.2.3": + version: 4.2.5 + resolution: "husky@npm:4.2.5" dependencies: - chalk: ^2.4.2 + chalk: ^4.0.0 ci-info: ^2.0.0 - cosmiconfig: ^5.2.1 - execa: ^1.0.0 - get-stdin: ^7.0.0 + compare-versions: ^3.6.0 + cosmiconfig: ^6.0.0 + find-versions: ^3.2.0 opencollective-postinstall: ^2.0.2 pkg-dir: ^4.2.0 please-upgrade-node: ^3.2.0 - read-pkg: ^5.2.0 - run-node: ^1.0.0 slash: ^3.0.0 + which-pm-runs: ^1.0.0 bin: - husky-run: ./run.js - husky-upgrade: ./lib/upgrader/bin.js - checksum: 697b20cd530cb7e9bc4491c49b9c112e25a7b758298a33b7d00ceed441f0584e886151d37db5e967ffef6d7363d77eb893129e7319845ec333c1b210b78c469b + husky-run: bin/run.js + husky-upgrade: lib/upgrader/bin.js + checksum: 9d03d38c66688ab61166b425aa70229665c93a2a6fbd0d7388923205622fe34c6cc4c251777337b0813a40891750a18d603eff8451a58d06953807535a8908ed languageName: node linkType: hard @@ -7940,7 +7959,7 @@ fsevents@^1.2.7: languageName: node linkType: hard -"import-fresh@npm:^3.0.0": +"import-fresh@npm:^3.0.0, import-fresh@npm:^3.1.0": version: 3.2.1 resolution: "import-fresh@npm:3.2.1" dependencies: @@ -8661,15 +8680,15 @@ fsevents@^1.2.7: languageName: node linkType: hard -"jest-diff@npm:^24.8.0": - version: 24.9.0 - resolution: "jest-diff@npm:24.9.0" +"jest-diff@npm:^25.1.0": + version: 25.5.0 + resolution: "jest-diff@npm:25.5.0" dependencies: - chalk: ^2.0.1 - diff-sequences: ^24.9.0 - jest-get-type: ^24.9.0 - pretty-format: ^24.9.0 - checksum: ba4aa10e5712ad365700921c90362dae8c2ab5b2c599b6f64fc4f3013f6208d760cb2980d491010e602e4a36b28a5c18fceba251f7602929d93300ae03ae931c + chalk: ^3.0.0 + diff-sequences: ^25.2.6 + jest-get-type: ^25.2.6 + pretty-format: ^25.5.0 + checksum: 14a2634ecb159a9a2f061239db1cea0c889e7a72ab05bd1fa799db30efca2ce79291372823f5e3468d9bc856f404f312e44e89c171eea8132b5835d12f71d0b3 languageName: node linkType: hard @@ -8736,10 +8755,10 @@ fsevents@^1.2.7: languageName: node linkType: hard -"jest-get-type@npm:^24.9.0": - version: 24.9.0 - resolution: "jest-get-type@npm:24.9.0" - checksum: 0e6164dff23f8cd664a46642d2167b743e67349c57ff908259b56e3f5c81f8d2a13de2dd473a1a3d7682adcfe85888d14b0496ba51c5c8095eb52bf7526c3918 +"jest-get-type@npm:^25.2.6": + version: 25.2.6 + resolution: "jest-get-type@npm:25.2.6" + checksum: 6051fcb75cdaa8fad66fd5a1e91d2c1597e9ccc54eecd5cd489fd73a00e322d28cb5859b656a8224a41eddab0ecfb875df9ec62f545a76afa1a55d3ba97fba6d languageName: node linkType: hard @@ -8768,6 +8787,7 @@ fsevents@^1.2.7: micromatch: ^4.0.2 sane: ^4.0.3 walker: ^1.0.7 + which: ^2.0.2 dependenciesMeta: fsevents: optional: true @@ -9068,6 +9088,13 @@ fsevents@^1.2.7: languageName: node linkType: hard +"js-tokens@npm:^6.0.0": + version: 6.0.0 + resolution: "js-tokens@npm:6.0.0" + checksum: 975859a4fd68cbaaabf106639df316e662b87b296afa9c6b00cfd25bc7642137433d18bf78e1e5578fc63c2a3e7334aad4fbed47f87c6c29f9a4f6760e79e322 + languageName: node + linkType: hard + "js-yaml@npm:^3.13.1, js-yaml@npm:^3.2.1": version: 3.13.1 resolution: "js-yaml@npm:3.13.1" @@ -9135,6 +9162,15 @@ fsevents@^1.2.7: languageName: node linkType: hard +"jsesc@npm:^3.0.1": + version: 3.0.1 + resolution: "jsesc@npm:3.0.1" + bin: + jsesc: bin/jsesc + checksum: a915daf0c74c86343bc91ac88030d20fd95cd433b451ad945585064855e6c66c7f1531196633dcad482effe42620af9fab4dd75af735cf41d180d8b515f7af77 + languageName: node + linkType: hard + "jsesc@npm:~0.5.0": version: 0.5.0 resolution: "jsesc@npm:0.5.0" @@ -9989,16 +10025,6 @@ fsevents@^1.2.7: languageName: node linkType: hard -"node-environment-flags@npm:^1.0.5": - version: 1.0.6 - resolution: "node-environment-flags@npm:1.0.6" - dependencies: - object.getownpropertydescriptors: ^2.0.3 - semver: ^5.7.0 - checksum: 1f6d1e636d5bb0caae32cd39b87b61ff1fa101d66db1ccb1417c8cb8df72089d10b0b5150bf10700c5f8a58f4f4ce7f64b1cf17392a3639b597e5fe9ea0dfcc0 - languageName: node - linkType: hard - "node-fetch@npm:^1.7.0": version: 1.7.3 resolution: "node-fetch@npm:1.7.3" @@ -10238,16 +10264,6 @@ fsevents@^1.2.7: languageName: node linkType: hard -"object.getownpropertydescriptors@npm:^2.0.3": - version: 2.0.3 - resolution: "object.getownpropertydescriptors@npm:2.0.3" - dependencies: - define-properties: ^1.1.2 - es-abstract: ^1.5.1 - checksum: aceab22c5f3890a44757053bd655ca4c10e28929ce55407c07c2c7b7e88225b75ecebdcc7f98c1b2c0e05ebe6a8903395b89d84233a9717d9684d9b6925fdfab - languageName: node - linkType: hard - "object.map@npm:^1.0.0": version: 1.0.1 resolution: "object.map@npm:1.0.1" @@ -10895,15 +10911,15 @@ fsevents@^1.2.7: languageName: node linkType: hard -"pretty-format@npm:^24.9.0": - version: 24.9.0 - resolution: "pretty-format@npm:24.9.0" +"pretty-format@npm:^25.5.0": + version: 25.5.0 + resolution: "pretty-format@npm:25.5.0" dependencies: - "@jest/types": ^24.9.0 - ansi-regex: ^4.0.0 - ansi-styles: ^3.2.0 - react-is: ^16.8.4 - checksum: a61c5c21a638239ebdc9bfe259746dc1aca29555f8da997318031ebee3ea36662f60f329132365c0cace2a0d122a1f7f9550261b3f04aaa18029d16efc5b45fe + "@jest/types": ^25.5.0 + ansi-regex: ^5.0.0 + ansi-styles: ^4.0.0 + react-is: ^16.12.0 + checksum: f7cc631d51e22c809d429d20facfd886ba0b212d419d153467872f68688256c2c55563bf70e943b7347ec9180b41a1d19c4235dc171850f9d5382a52959c0245 languageName: node linkType: hard @@ -11091,7 +11107,7 @@ fsevents@^1.2.7: languageName: node linkType: hard -"react-is@npm:^16.8.4": +"react-is@npm:^16.12.0": version: 16.13.1 resolution: "react-is@npm:16.13.1" checksum: 11bcf1267a314a522615f626f3ce3727a3a24cdbf61c4d452add3550a7875326669631326cfb1ba3e92b6f72244c32ffecf93ad21c0cad8455d3e169d0e3f060 @@ -11517,7 +11533,7 @@ fsevents@^1.2.7: languageName: node linkType: hard -"resolve@^1.1.4, resolve@^1.1.6, resolve@^1.1.7, resolve@^1.10.0, resolve@^1.11.0, resolve@^1.13.1, resolve@^1.15.0, resolve@^1.17.0, resolve@^1.18.1, resolve@^1.3.2, resolve@^1.4.0, resolve@^1.8.1": +"resolve@^1.1.4, resolve@^1.1.6, resolve@^1.1.7, resolve@^1.10.0, resolve@^1.11.0, resolve@^1.13.1, resolve@^1.17.0, resolve@^1.18.1, resolve@^1.3.2, resolve@^1.4.0, resolve@^1.8.1": version: 1.18.1 resolution: "resolve@npm:1.18.1" dependencies: @@ -11527,7 +11543,7 @@ fsevents@^1.2.7: languageName: node linkType: hard -"resolve@patch:resolve@^1.1.4#builtin, resolve@patch:resolve@^1.1.6#builtin, resolve@patch:resolve@^1.1.7#builtin, resolve@patch:resolve@^1.10.0#builtin, resolve@patch:resolve@^1.11.0#builtin, resolve@patch:resolve@^1.13.1#builtin, resolve@patch:resolve@^1.15.0#builtin, resolve@patch:resolve@^1.17.0#builtin, resolve@patch:resolve@^1.18.1#builtin, resolve@patch:resolve@^1.3.2#builtin, resolve@patch:resolve@^1.4.0#builtin, resolve@patch:resolve@^1.8.1#builtin": +"resolve@patch:resolve@^1.1.4#builtin, resolve@patch:resolve@^1.1.6#builtin, resolve@patch:resolve@^1.1.7#builtin, resolve@patch:resolve@^1.10.0#builtin, resolve@patch:resolve@^1.11.0#builtin, resolve@patch:resolve@^1.13.1#builtin, resolve@patch:resolve@^1.17.0#builtin, resolve@patch:resolve@^1.18.1#builtin, resolve@patch:resolve@^1.3.2#builtin, resolve@patch:resolve@^1.4.0#builtin, resolve@patch:resolve@^1.8.1#builtin": version: 1.18.1 resolution: "resolve@patch:resolve@npm%3A1.18.1#builtin::version=1.18.1&hash=3388aa" dependencies: @@ -11668,15 +11684,6 @@ fsevents@^1.2.7: languageName: node linkType: hard -"run-node@npm:^1.0.0": - version: 1.0.0 - resolution: "run-node@npm:1.0.0" - bin: - run-node: run-node - checksum: 8e154ab24e086443a440728407daff84b5682d80f0c457cd9887bc197f8c3947a67deae5b69d36aa90729c7b5ecfb82c91a9cfcb0dc57e1e5c4dcf7256dd185c - languageName: node - linkType: hard - "run-parallel@npm:^1.1.9": version: 1.1.9 resolution: "run-parallel@npm:1.1.9" @@ -11767,7 +11774,14 @@ fsevents@^1.2.7: languageName: node linkType: hard -"semver@npm:2 || 3 || 4 || 5, semver@npm:^5.3.0, semver@npm:^5.4.1, semver@npm:^5.5.0, semver@npm:^5.5.1, semver@npm:^5.6.0, semver@npm:^5.7.0": +"semver-regex@npm:^2.0.0": + version: 2.0.0 + resolution: "semver-regex@npm:2.0.0" + checksum: 9b96cc8bd559c1d46968b334ccc88115a2d9d2f7a2125d6838471114ed0c52057e77aae760fbe4932aee06687584733b32aed6d2c9654b2db33e383bfb8f26ce + languageName: node + linkType: hard + +"semver@npm:2 || 3 || 4 || 5, semver@npm:^5.3.0, semver@npm:^5.4.1, semver@npm:^5.5.0, semver@npm:^5.5.1, semver@npm:^5.6.0": version: 5.7.1 resolution: "semver@npm:5.7.1" bin: @@ -13341,6 +13355,13 @@ typescript@^3.6.3: languageName: node linkType: hard +"which-pm-runs@npm:^1.0.0": + version: 1.0.0 + resolution: "which-pm-runs@npm:1.0.0" + checksum: 0bb79a782e98955afec8f35a3ae95c4711fdd3d0743772ee98211da67c2421fdd4c92c95c93532cc0b4dcc085d8e27f3ad2f8a9173cb632692379bd3d2818821 + languageName: node + linkType: hard + "which@npm:^1.2.14, which@npm:^1.2.9": version: 1.3.1 resolution: "which@npm:1.3.1" @@ -13495,6 +13516,13 @@ typescript@^3.6.3: languageName: node linkType: hard +"yaml@npm:^1.7.2": + version: 1.10.0 + resolution: "yaml@npm:1.10.0" + checksum: d4cc9f9724f8d0aebc2cf52e4e6aa7059f12d50deb54b5225d103462fb2af36e5c0bb419101ca4b1f0cd3b4db9e4139cf2c690e863ac6227648d39d6f4e2522c + languageName: node + linkType: hard + "yargs-parser@npm:5.0.0-security.0": version: 5.0.0-security.0 resolution: "yargs-parser@npm:5.0.0-security.0"