@neon-rs/cli
Version:
Command-line build tool for Neon modules.
1,457 lines (1,384 loc) • 2.48 MB
JavaScript
#!/usr/bin/env node
import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
/******/ var __webpack_modules__ = ({
/***/ 8938:
/***/ ((__unused_webpack_module, exports) => {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
__webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = exports.ob = void 0;
function currentPlatform() {
let os = null;
switch (process.platform) {
case 'android':
switch (process.arch) {
case 'arm':
return 'android-arm-eabi';
case 'arm64':
return 'android-arm64';
}
os = 'Android';
break;
case 'win32':
switch (process.arch) {
case 'x64':
return 'win32-x64-msvc';
case 'arm64':
return 'win32-arm64-msvc';
case 'ia32':
return 'win32-ia32-msvc';
}
os = 'Windows';
break;
case 'darwin':
switch (process.arch) {
case 'x64':
return 'darwin-x64';
case 'arm64':
return 'darwin-arm64';
}
os = 'macOS';
break;
case 'linux':
switch (process.arch) {
case 'x64':
case 'arm64':
return isGlibc()
? `linux-${process.arch}-gnu`
: `linux-${process.arch}-musl`;
case 'arm':
return 'linux-arm-gnueabihf';
}
os = 'Linux';
break;
case 'freebsd':
if (process.arch === 'x64') {
return 'freebsd-x64';
}
os = 'FreeBSD';
break;
}
if (os) {
throw new Error(`Neon: unsupported ${os} architecture: ${process.arch}`);
}
throw new Error(`Neon: unsupported system: ${process.platform}`);
}
exports.ob = currentPlatform;
// DEPRECATE(0.1)
function currentTarget() {
return currentPlatform();
}
__webpack_unused_export__ = currentTarget;
function isGlibc() {
// Cast to unknown to work around a bug in the type definition:
// https://github.com/DefinitelyTyped/DefinitelyTyped/issues/40140
const report = process.report?.getReport();
if ((typeof report !== 'object') || !report || (!('header' in report))) {
return false;
}
const header = report.header;
return (typeof header === 'object') &&
!!header &&
('glibcVersionRuntime' in header);
}
// export function debug(...components: string[]) {
// if (components.length === 0 || !components[components.length - 1].endsWith(".node")) {
// components.push("index.node");
// }
// const pathSpec = path.join(...components);
// return fs.existsSync(pathSpec) ? require(pathSpec) : null;
// }
function* interleave(a1, a2) {
const length = Math.max(a1.length, a2.length);
for (let i = 0; i < length; i++) {
if (i < a1.length) {
yield a1[i];
}
if (i < a2.length) {
yield a2[i];
}
}
}
function bin(scope, ...rest) {
return [...interleave(scope, rest)].join("") + "/" + currentPlatform();
}
__webpack_unused_export__ = bin;
// DEPRECATE(0.1)
function lazyV1(loaders, exports) {
return lazyV2({
targets: loaders,
exports
});
}
// DEPRECATE(0.1)
function lazyV2(options) {
return lazyV3({
platforms: options.targets,
exports: options.exports,
debug: options.debug
});
}
function lazyV3(options) {
const loaders = options.platforms;
let loaded = null;
function load() {
if (loaded) {
return loaded;
}
const platform = currentPlatform();
if (!loaders.hasOwnProperty(platform)) {
throw new Error(`no precompiled module found for ${platform}`);
}
if (options.debug) {
try {
loaded = options.debug();
}
catch (_e) {
loaded = null;
}
}
if (!loaded) {
loaded = loaders[platform]();
}
return loaded;
}
let module = {};
for (const key of options.exports) {
Object.defineProperty(module, key, { get() { return load()[key]; } });
}
return module;
}
function lazy(optionsOrLoaders, exports) {
return (!exports && !('targets' in optionsOrLoaders))
? lazyV3(optionsOrLoaders)
: !exports
? lazyV2(optionsOrLoaders)
: lazyV1(optionsOrLoaders, exports);
}
__webpack_unused_export__ = lazy;
function __UNSTABLE_loader(loaders) {
const platform = currentPlatform();
if (!loaders.hasOwnProperty(platform)) {
throw new Error(`no precompiled module found for ${platform}`);
}
const loader = loaders[platform];
let loaded = null;
return () => {
if (loaded) {
return loaded;
}
loaded = loader();
return loaded;
};
}
__webpack_unused_export__ = __UNSTABLE_loader;
// DEPRECATE(0.1)
function isDeprecatedProxyOptions(options) {
return 'targets' in options;
}
function isProxyOptions(options) {
return 'platforms' in options;
}
function proxy(options) {
const opts = isProxyOptions(options)
? options
: !isDeprecatedProxyOptions(options)
? { platforms: options }
: { platforms: options.targets, debug: options.debug };
const platform = currentPlatform();
const loaders = opts.platforms;
if (!loaders.hasOwnProperty(platform)) {
throw new Error(`no precompiled module found for ${platform}`);
}
const loader = loaders[platform];
let loaded = null;
function load() {
if (!loaded) {
if (options.debug) {
try {
loaded = options.debug();
}
catch (_e) {
loaded = null;
}
}
if (!loaded) {
loaded = loader();
}
}
return loaded;
}
const handler = {
has(_target, key) {
return Reflect.has(load(), key);
},
get(_target, key) {
return Reflect.get(load(), key);
},
ownKeys(_target) {
return Reflect.ownKeys(load());
},
defineProperty(_target, _key, _descriptor) {
throw new Error('attempt to modify read-only Neon module proxy');
},
deleteProperty(_target, _key) {
throw new Error('attempt to modify read-only Neon module proxy');
},
set(_target, _key, _val) {
throw new Error('attempt to modify read-only Neon module proxy');
},
setPrototypeOf(_target, _proto) {
throw new Error('attempt to modify read-only Neon module proxy');
},
getPrototypeOf(_target) {
return Object.getPrototypeOf(load());
},
isExtensible(_target) {
return Reflect.isExtensible(load());
},
preventExtensions(_target) {
return Reflect.preventExtensions(load());
},
getOwnPropertyDescriptor(_target, key) {
return Reflect.getOwnPropertyDescriptor(load(), key);
}
};
return new Proxy({}, handler);
}
__webpack_unused_export__ = proxy;
// DEPRECATE(0.1)
function __UNSTABLE_proxy(options) {
return proxy(options);
}
__webpack_unused_export__ = __UNSTABLE_proxy;
/***/ }),
/***/ 8372:
/***/ ((__unused_webpack_module, exports) => {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
__webpack_unused_export__ = exports.sj = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = void 0;
function currentPlatform() {
let os = null;
switch (process.platform) {
case 'android':
switch (process.arch) {
case 'arm':
return 'android-arm-eabi';
case 'arm64':
return 'android-arm64';
}
os = 'Android';
break;
case 'win32':
switch (process.arch) {
case 'x64':
return 'win32-x64-msvc';
case 'arm64':
return 'win32-arm64-msvc';
case 'ia32':
return 'win32-ia32-msvc';
}
os = 'Windows';
break;
case 'darwin':
switch (process.arch) {
case 'x64':
return 'darwin-x64';
case 'arm64':
return 'darwin-arm64';
}
os = 'macOS';
break;
case 'linux':
switch (process.arch) {
case 'x64':
case 'arm64':
return isGlibc()
? `linux-${process.arch}-gnu`
: `linux-${process.arch}-musl`;
case 'arm':
return 'linux-arm-gnueabihf';
}
os = 'Linux';
break;
case 'freebsd':
if (process.arch === 'x64') {
return 'freebsd-x64';
}
os = 'FreeBSD';
break;
}
if (os) {
throw new Error(`Neon: unsupported ${os} architecture: ${process.arch}`);
}
throw new Error(`Neon: unsupported system: ${process.platform}`);
}
__webpack_unused_export__ = currentPlatform;
// DEPRECATE(0.1)
function currentTarget() {
return currentPlatform();
}
__webpack_unused_export__ = currentTarget;
function isGlibc() {
// Cast to unknown to work around a bug in the type definition:
// https://github.com/DefinitelyTyped/DefinitelyTyped/issues/40140
const report = process.report?.getReport();
if ((typeof report !== 'object') || !report || (!('header' in report))) {
return false;
}
const header = report.header;
return (typeof header === 'object') &&
!!header &&
('glibcVersionRuntime' in header);
}
// export function debug(...components: string[]) {
// if (components.length === 0 || !components[components.length - 1].endsWith(".node")) {
// components.push("index.node");
// }
// const pathSpec = path.join(...components);
// return fs.existsSync(pathSpec) ? require(pathSpec) : null;
// }
function* interleave(a1, a2) {
const length = Math.max(a1.length, a2.length);
for (let i = 0; i < length; i++) {
if (i < a1.length) {
yield a1[i];
}
if (i < a2.length) {
yield a2[i];
}
}
}
function bin(scope, ...rest) {
return [...interleave(scope, rest)].join("") + "/" + currentPlatform();
}
__webpack_unused_export__ = bin;
// DEPRECATE(0.1)
function lazyV1(loaders, exports) {
return lazyV2({
targets: loaders,
exports
});
}
// DEPRECATE(0.1)
function lazyV2(options) {
return lazyV3({
platforms: options.targets,
exports: options.exports,
debug: options.debug
});
}
function lazyV3(options) {
const loaders = options.platforms;
let loaded = null;
function load() {
if (loaded) {
return loaded;
}
const platform = currentPlatform();
if (!loaders.hasOwnProperty(platform)) {
throw new Error(`no precompiled module found for ${platform}`);
}
if (options.debug) {
try {
loaded = options.debug();
}
catch (_e) {
loaded = null;
}
}
if (!loaded) {
loaded = loaders[platform]();
}
return loaded;
}
let module = {};
for (const key of options.exports) {
Object.defineProperty(module, key, { get() { return load()[key]; } });
}
return module;
}
function lazy(optionsOrLoaders, exports) {
return (!exports && !('targets' in optionsOrLoaders))
? lazyV3(optionsOrLoaders)
: !exports
? lazyV2(optionsOrLoaders)
: lazyV1(optionsOrLoaders, exports);
}
__webpack_unused_export__ = lazy;
function __UNSTABLE_loader(loaders) {
const platform = currentPlatform();
if (!loaders.hasOwnProperty(platform)) {
throw new Error(`no precompiled module found for ${platform}`);
}
const loader = loaders[platform];
let loaded = null;
return () => {
if (loaded) {
return loaded;
}
loaded = loader();
return loaded;
};
}
__webpack_unused_export__ = __UNSTABLE_loader;
// DEPRECATE(0.1)
function isDeprecatedProxyOptions(options) {
return 'targets' in options;
}
function isProxyOptions(options) {
return 'platforms' in options;
}
function proxy(options) {
const opts = isProxyOptions(options)
? options
: !isDeprecatedProxyOptions(options)
? { platforms: options }
: { platforms: options.targets, debug: options.debug };
const platform = currentPlatform();
const loaders = opts.platforms;
if (!loaders.hasOwnProperty(platform)) {
throw new Error(`no precompiled module found for ${platform}`);
}
const loader = loaders[platform];
let loaded = null;
function load() {
if (!loaded) {
if (options.debug) {
try {
loaded = options.debug();
}
catch (_e) {
loaded = null;
}
}
if (!loaded) {
loaded = loader();
}
}
return loaded;
}
const handler = {
has(_target, key) {
return Reflect.has(load(), key);
},
get(_target, key) {
return Reflect.get(load(), key);
},
ownKeys(_target) {
return Reflect.ownKeys(load());
},
defineProperty(_target, _key, _descriptor) {
throw new Error('attempt to modify read-only Neon module proxy');
},
deleteProperty(_target, _key) {
throw new Error('attempt to modify read-only Neon module proxy');
},
set(_target, _key, _val) {
throw new Error('attempt to modify read-only Neon module proxy');
},
setPrototypeOf(_target, _proto) {
throw new Error('attempt to modify read-only Neon module proxy');
},
getPrototypeOf(_target) {
return Object.getPrototypeOf(load());
},
isExtensible(_target) {
return Reflect.isExtensible(load());
},
preventExtensions(_target) {
return Reflect.preventExtensions(load());
},
getOwnPropertyDescriptor(_target, key) {
return Reflect.getOwnPropertyDescriptor(load(), key);
}
};
return new Proxy({}, handler);
}
exports.sj = proxy;
// DEPRECATE(0.1)
function __UNSTABLE_proxy(options) {
return proxy(options);
}
__webpack_unused_export__ = __UNSTABLE_proxy;
/***/ }),
/***/ 7566:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
const wrapAnsi16 = (fn, offset) => (...args) => {
const code = fn(...args);
return `\u001B[${code + offset}m`;
};
const wrapAnsi256 = (fn, offset) => (...args) => {
const code = fn(...args);
return `\u001B[${38 + offset};5;${code}m`;
};
const wrapAnsi16m = (fn, offset) => (...args) => {
const rgb = fn(...args);
return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
};
const ansi2ansi = n => n;
const rgb2rgb = (r, g, b) => [r, g, b];
const setLazyProperty = (object, property, get) => {
Object.defineProperty(object, property, {
get: () => {
const value = get();
Object.defineProperty(object, property, {
value,
enumerable: true,
configurable: true
});
return value;
},
enumerable: true,
configurable: true
});
};
/** @type {typeof import('color-convert')} */
let colorConvert;
const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
if (colorConvert === undefined) {
colorConvert = __nccwpck_require__(2441);
}
const offset = isBackground ? 10 : 0;
const styles = {};
for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
if (sourceSpace === targetSpace) {
styles[name] = wrap(identity, offset);
} else if (typeof suite === 'object') {
styles[name] = wrap(suite[targetSpace], offset);
}
}
return styles;
};
function assembleStyles() {
const codes = new Map();
const styles = {
modifier: {
reset: [0, 0],
// 21 isn't widely supported and 22 does the same thing
bold: [1, 22],
dim: [2, 22],
italic: [3, 23],
underline: [4, 24],
inverse: [7, 27],
hidden: [8, 28],
strikethrough: [9, 29]
},
color: {
black: [30, 39],
red: [31, 39],
green: [32, 39],
yellow: [33, 39],
blue: [34, 39],
magenta: [35, 39],
cyan: [36, 39],
white: [37, 39],
// Bright color
blackBright: [90, 39],
redBright: [91, 39],
greenBright: [92, 39],
yellowBright: [93, 39],
blueBright: [94, 39],
magentaBright: [95, 39],
cyanBright: [96, 39],
whiteBright: [97, 39]
},
bgColor: {
bgBlack: [40, 49],
bgRed: [41, 49],
bgGreen: [42, 49],
bgYellow: [43, 49],
bgBlue: [44, 49],
bgMagenta: [45, 49],
bgCyan: [46, 49],
bgWhite: [47, 49],
// Bright color
bgBlackBright: [100, 49],
bgRedBright: [101, 49],
bgGreenBright: [102, 49],
bgYellowBright: [103, 49],
bgBlueBright: [104, 49],
bgMagentaBright: [105, 49],
bgCyanBright: [106, 49],
bgWhiteBright: [107, 49]
}
};
// Alias bright black as gray (and grey)
styles.color.gray = styles.color.blackBright;
styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
styles.color.grey = styles.color.blackBright;
styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
for (const [groupName, group] of Object.entries(styles)) {
for (const [styleName, style] of Object.entries(group)) {
styles[styleName] = {
open: `\u001B[${style[0]}m`,
close: `\u001B[${style[1]}m`
};
group[styleName] = styles[styleName];
codes.set(style[0], style[1]);
}
Object.defineProperty(styles, groupName, {
value: group,
enumerable: false
});
}
Object.defineProperty(styles, 'codes', {
value: codes,
enumerable: false
});
styles.color.close = '\u001B[39m';
styles.bgColor.close = '\u001B[49m';
setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
return styles;
}
// Make the export immutable
Object.defineProperty(module, 'exports', {
enumerable: true,
get: assembleStyles
});
/***/ }),
/***/ 8751:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var es_proposals_1 = tslib_1.__importDefault(__nccwpck_require__(3676));
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var shared_1 = tslib_1.__importStar(__nccwpck_require__(4456));
function default_1(fork) {
var _a, _b, _c, _d, _e;
fork.use(es_proposals_1.default);
var types = fork.use(types_1.default);
var defaults = fork.use(shared_1.default).defaults;
var def = types.Type.def;
var or = types.Type.or;
var isUndefined = types.builtInTypes.undefined;
def("Noop")
.bases("Statement")
.build();
def("DoExpression")
.bases("Expression")
.build("body")
.field("body", [def("Statement")]);
def("BindExpression")
.bases("Expression")
.build("object", "callee")
.field("object", or(def("Expression"), null))
.field("callee", def("Expression"));
def("ParenthesizedExpression")
.bases("Expression")
.build("expression")
.field("expression", def("Expression"));
def("ExportNamespaceSpecifier")
.bases("Specifier")
.build("exported")
.field("exported", def("Identifier"));
def("ExportDefaultSpecifier")
.bases("Specifier")
.build("exported")
.field("exported", def("Identifier"));
def("CommentBlock")
.bases("Comment")
.build("value", /*optional:*/ "leading", "trailing");
def("CommentLine")
.bases("Comment")
.build("value", /*optional:*/ "leading", "trailing");
def("Directive")
.bases("Node")
.build("value")
.field("value", def("DirectiveLiteral"));
def("DirectiveLiteral")
.bases("Node", "Expression")
.build("value")
.field("value", String, defaults["use strict"]);
def("InterpreterDirective")
.bases("Node")
.build("value")
.field("value", String);
def("BlockStatement")
.bases("Statement")
.build("body")
.field("body", [def("Statement")])
.field("directives", [def("Directive")], defaults.emptyArray);
def("Program")
.bases("Node")
.build("body")
.field("body", [def("Statement")])
.field("directives", [def("Directive")], defaults.emptyArray)
.field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]);
function makeLiteralExtra(rawValueType, toRaw) {
if (rawValueType === void 0) { rawValueType = String; }
return [
"extra",
{
rawValue: rawValueType,
raw: String,
},
function getDefault() {
var value = types.getFieldValue(this, "value");
return {
rawValue: value,
raw: toRaw ? toRaw(value) : String(value),
};
},
];
}
// Split Literal
(_a = def("StringLiteral")
.bases("Literal")
.build("value")
.field("value", String))
.field.apply(_a, makeLiteralExtra(String, function (val) { return JSON.stringify(val); }));
(_b = def("NumericLiteral")
.bases("Literal")
.build("value")
.field("value", Number)
.field("raw", or(String, null), defaults["null"]))
.field.apply(_b, makeLiteralExtra(Number));
(_c = def("BigIntLiteral")
.bases("Literal")
.build("value")
// Only String really seems appropriate here, since BigInt values
// often exceed the limits of JS numbers.
.field("value", or(String, Number)))
.field.apply(_c, makeLiteralExtra(String, function (val) { return val + "n"; }));
// https://github.com/tc39/proposal-decimal
// https://github.com/babel/babel/pull/11640
(_d = def("DecimalLiteral")
.bases("Literal")
.build("value")
.field("value", String))
.field.apply(_d, makeLiteralExtra(String, function (val) { return val + "m"; }));
def("NullLiteral")
.bases("Literal")
.build()
.field("value", null, defaults["null"]);
def("BooleanLiteral")
.bases("Literal")
.build("value")
.field("value", Boolean);
(_e = def("RegExpLiteral")
.bases("Literal")
.build("pattern", "flags")
.field("pattern", String)
.field("flags", String)
.field("value", RegExp, function () {
return new RegExp(this.pattern, this.flags);
}))
.field.apply(_e, makeLiteralExtra(or(RegExp, isUndefined), function (exp) { return "/".concat(exp.pattern, "/").concat(exp.flags || ""); })).field("regex", {
pattern: String,
flags: String
}, function () {
return {
pattern: this.pattern,
flags: this.flags,
};
});
var ObjectExpressionProperty = or(def("Property"), def("ObjectMethod"), def("ObjectProperty"), def("SpreadProperty"), def("SpreadElement"));
// Split Property -> ObjectProperty and ObjectMethod
def("ObjectExpression")
.bases("Expression")
.build("properties")
.field("properties", [ObjectExpressionProperty]);
// ObjectMethod hoist .value properties to own properties
def("ObjectMethod")
.bases("Node", "Function")
.build("kind", "key", "params", "body", "computed")
.field("kind", or("method", "get", "set"))
.field("key", or(def("Literal"), def("Identifier"), def("Expression")))
.field("params", [def("Pattern")])
.field("body", def("BlockStatement"))
.field("computed", Boolean, defaults["false"])
.field("generator", Boolean, defaults["false"])
.field("async", Boolean, defaults["false"])
.field("accessibility", // TypeScript
or(def("Literal"), null), defaults["null"])
.field("decorators", or([def("Decorator")], null), defaults["null"]);
def("ObjectProperty")
.bases("Node")
.build("key", "value")
.field("key", or(def("Literal"), def("Identifier"), def("Expression")))
.field("value", or(def("Expression"), def("Pattern")))
.field("accessibility", // TypeScript
or(def("Literal"), null), defaults["null"])
.field("computed", Boolean, defaults["false"]);
var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod"), def("ClassAccessorProperty"), def("StaticBlock"));
// MethodDefinition -> ClassMethod
def("ClassBody")
.bases("Declaration")
.build("body")
.field("body", [ClassBodyElement]);
def("ClassMethod")
.bases("Declaration", "Function")
.build("kind", "key", "params", "body", "computed", "static")
.field("key", or(def("Literal"), def("Identifier"), def("Expression")));
def("ClassPrivateMethod")
.bases("Declaration", "Function")
.build("key", "params", "body", "kind", "computed", "static")
.field("key", def("PrivateName"));
def("ClassAccessorProperty")
.bases("Declaration")
.build("key", "value", "decorators", "computed", "static")
.field("key", or(def("Literal"), def("Identifier"), def("PrivateName"),
// Only when .computed is true (TODO enforce this)
def("Expression")))
.field("value", or(def("Expression"), null), defaults["null"]);
["ClassMethod",
"ClassPrivateMethod",
].forEach(function (typeName) {
def(typeName)
.field("kind", or("get", "set", "method", "constructor"), function () { return "method"; })
.field("body", def("BlockStatement"))
// For backwards compatibility only. Expect accessibility instead (see below).
.field("access", or("public", "private", "protected", null), defaults["null"]);
});
["ClassMethod",
"ClassPrivateMethod",
"ClassAccessorProperty",
].forEach(function (typeName) {
def(typeName)
.field("computed", Boolean, defaults["false"])
.field("static", Boolean, defaults["false"])
.field("abstract", Boolean, defaults["false"])
.field("accessibility", or("public", "private", "protected", null), defaults["null"])
.field("decorators", or([def("Decorator")], null), defaults["null"])
.field("definite", Boolean, defaults["false"])
.field("optional", Boolean, defaults["false"])
.field("override", Boolean, defaults["false"])
.field("readonly", Boolean, defaults["false"]);
});
var ObjectPatternProperty = or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty"), // Used by Esprima
def("ObjectProperty"), // Babel 6
def("RestProperty"), // Babel 6
def("RestElement"));
// Split into RestProperty and SpreadProperty
def("ObjectPattern")
.bases("Pattern")
.build("properties")
.field("properties", [ObjectPatternProperty])
.field("decorators", or([def("Decorator")], null), defaults["null"]);
def("SpreadProperty")
.bases("Node")
.build("argument")
.field("argument", def("Expression"));
def("RestProperty")
.bases("Node")
.build("argument")
.field("argument", def("Expression"));
def("ForAwaitStatement")
.bases("Statement")
.build("left", "right", "body")
.field("left", or(def("VariableDeclaration"), def("Expression")))
.field("right", def("Expression"))
.field("body", def("Statement"));
// The callee node of a dynamic import(...) expression.
def("Import")
.bases("Expression")
.build();
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=babel-core.js.map
/***/ }),
/***/ 2794:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var babel_core_1 = tslib_1.__importDefault(__nccwpck_require__(8751));
var flow_1 = tslib_1.__importDefault(__nccwpck_require__(4110));
var shared_1 = __nccwpck_require__(4456);
function default_1(fork) {
var types = fork.use(types_1.default);
var def = types.Type.def;
fork.use(babel_core_1.default);
fork.use(flow_1.default);
// https://github.com/babel/babel/pull/10148
def("V8IntrinsicIdentifier")
.bases("Expression")
.build("name")
.field("name", String);
// https://github.com/babel/babel/pull/13191
// https://github.com/babel/website/pull/2541
def("TopicReference")
.bases("Expression")
.build();
}
exports["default"] = default_1;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=babel.js.map
/***/ }),
/***/ 8256:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var core_1 = tslib_1.__importDefault(__nccwpck_require__(732));
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var shared_1 = tslib_1.__importStar(__nccwpck_require__(4456));
function default_1(fork) {
var types = fork.use(types_1.default);
var Type = types.Type;
var def = Type.def;
var or = Type.or;
var shared = fork.use(shared_1.default);
var defaults = shared.defaults;
var geq = shared.geq;
var _a = fork.use(core_1.default), BinaryOperators = _a.BinaryOperators, AssignmentOperators = _a.AssignmentOperators, LogicalOperators = _a.LogicalOperators;
// Abstract supertype of all syntactic entities that are allowed to have a
// .loc field.
def("Printable")
.field("loc", or(def("SourceLocation"), null), defaults["null"], true);
def("Node")
.bases("Printable")
.field("type", String)
.field("comments", or([def("Comment")], null), defaults["null"], true);
def("SourceLocation")
.field("start", def("Position"))
.field("end", def("Position"))
.field("source", or(String, null), defaults["null"]);
def("Position")
.field("line", geq(1))
.field("column", geq(0));
def("File")
.bases("Node")
.build("program", "name")
.field("program", def("Program"))
.field("name", or(String, null), defaults["null"]);
def("Program")
.bases("Node")
.build("body")
.field("body", [def("Statement")]);
def("Function")
.bases("Node")
.field("id", or(def("Identifier"), null), defaults["null"])
.field("params", [def("Pattern")])
.field("body", def("BlockStatement"))
.field("generator", Boolean, defaults["false"])
.field("async", Boolean, defaults["false"]);
def("Statement").bases("Node");
// The empty .build() here means that an EmptyStatement can be constructed
// (i.e. it's not abstract) but that it needs no arguments.
def("EmptyStatement").bases("Statement").build();
def("BlockStatement")
.bases("Statement")
.build("body")
.field("body", [def("Statement")]);
// TODO Figure out how to silently coerce Expressions to
// ExpressionStatements where a Statement was expected.
def("ExpressionStatement")
.bases("Statement")
.build("expression")
.field("expression", def("Expression"));
def("IfStatement")
.bases("Statement")
.build("test", "consequent", "alternate")
.field("test", def("Expression"))
.field("consequent", def("Statement"))
.field("alternate", or(def("Statement"), null), defaults["null"]);
def("LabeledStatement")
.bases("Statement")
.build("label", "body")
.field("label", def("Identifier"))
.field("body", def("Statement"));
def("BreakStatement")
.bases("Statement")
.build("label")
.field("label", or(def("Identifier"), null), defaults["null"]);
def("ContinueStatement")
.bases("Statement")
.build("label")
.field("label", or(def("Identifier"), null), defaults["null"]);
def("WithStatement")
.bases("Statement")
.build("object", "body")
.field("object", def("Expression"))
.field("body", def("Statement"));
def("SwitchStatement")
.bases("Statement")
.build("discriminant", "cases", "lexical")
.field("discriminant", def("Expression"))
.field("cases", [def("SwitchCase")])
.field("lexical", Boolean, defaults["false"]);
def("ReturnStatement")
.bases("Statement")
.build("argument")
.field("argument", or(def("Expression"), null));
def("ThrowStatement")
.bases("Statement")
.build("argument")
.field("argument", def("Expression"));
def("TryStatement")
.bases("Statement")
.build("block", "handler", "finalizer")
.field("block", def("BlockStatement"))
.field("handler", or(def("CatchClause"), null), function () {
return this.handlers && this.handlers[0] || null;
})
.field("handlers", [def("CatchClause")], function () {
return this.handler ? [this.handler] : [];
}, true) // Indicates this field is hidden from eachField iteration.
.field("guardedHandlers", [def("CatchClause")], defaults.emptyArray)
.field("finalizer", or(def("BlockStatement"), null), defaults["null"]);
def("CatchClause")
.bases("Node")
.build("param", "guard", "body")
.field("param", def("Pattern"))
.field("guard", or(def("Expression"), null), defaults["null"])
.field("body", def("BlockStatement"));
def("WhileStatement")
.bases("Statement")
.build("test", "body")
.field("test", def("Expression"))
.field("body", def("Statement"));
def("DoWhileStatement")
.bases("Statement")
.build("body", "test")
.field("body", def("Statement"))
.field("test", def("Expression"));
def("ForStatement")
.bases("Statement")
.build("init", "test", "update", "body")
.field("init", or(def("VariableDeclaration"), def("Expression"), null))
.field("test", or(def("Expression"), null))
.field("update", or(def("Expression"), null))
.field("body", def("Statement"));
def("ForInStatement")
.bases("Statement")
.build("left", "right", "body")
.field("left", or(def("VariableDeclaration"), def("Expression")))
.field("right", def("Expression"))
.field("body", def("Statement"));
def("DebuggerStatement").bases("Statement").build();
def("Declaration").bases("Statement");
def("FunctionDeclaration")
.bases("Function", "Declaration")
.build("id", "params", "body")
.field("id", def("Identifier"));
def("FunctionExpression")
.bases("Function", "Expression")
.build("id", "params", "body");
def("VariableDeclaration")
.bases("Declaration")
.build("kind", "declarations")
.field("kind", or("var", "let", "const"))
.field("declarations", [def("VariableDeclarator")]);
def("VariableDeclarator")
.bases("Node")
.build("id", "init")
.field("id", def("Pattern"))
.field("init", or(def("Expression"), null), defaults["null"]);
def("Expression").bases("Node");
def("ThisExpression").bases("Expression").build();
def("ArrayExpression")
.bases("Expression")
.build("elements")
.field("elements", [or(def("Expression"), null)]);
def("ObjectExpression")
.bases("Expression")
.build("properties")
.field("properties", [def("Property")]);
// TODO Not in the Mozilla Parser API, but used by Esprima.
def("Property")
.bases("Node") // Want to be able to visit Property Nodes.
.build("kind", "key", "value")
.field("kind", or("init", "get", "set"))
.field("key", or(def("Literal"), def("Identifier")))
.field("value", def("Expression"));
def("SequenceExpression")
.bases("Expression")
.build("expressions")
.field("expressions", [def("Expression")]);
var UnaryOperator = or("-", "+", "!", "~", "typeof", "void", "delete");
def("UnaryExpression")
.bases("Expression")
.build("operator", "argument", "prefix")
.field("operator", UnaryOperator)
.field("argument", def("Expression"))
// Esprima doesn't bother with this field, presumably because it's
// always true for unary operators.
.field("prefix", Boolean, defaults["true"]);
var BinaryOperator = or.apply(void 0, BinaryOperators);
def("BinaryExpression")
.bases("Expression")
.build("operator", "left", "right")
.field("operator", BinaryOperator)
.field("left", def("Expression"))
.field("right", def("Expression"));
var AssignmentOperator = or.apply(void 0, AssignmentOperators);
def("AssignmentExpression")
.bases("Expression")
.build("operator", "left", "right")
.field("operator", AssignmentOperator)
.field("left", or(def("Pattern"), def("MemberExpression")))
.field("right", def("Expression"));
var UpdateOperator = or("++", "--");
def("UpdateExpression")
.bases("Expression")
.build("operator", "argument", "prefix")
.field("operator", UpdateOperator)
.field("argument", def("Expression"))
.field("prefix", Boolean);
var LogicalOperator = or.apply(void 0, LogicalOperators);
def("LogicalExpression")
.bases("Expression")
.build("operator", "left", "right")
.field("operator", LogicalOperator)
.field("left", def("Expression"))
.field("right", def("Expression"));
def("ConditionalExpression")
.bases("Expression")
.build("test", "consequent", "alternate")
.field("test", def("Expression"))
.field("consequent", def("Expression"))
.field("alternate", def("Expression"));
def("NewExpression")
.bases("Expression")
.build("callee", "arguments")
.field("callee", def("Expression"))
// The Mozilla Parser API gives this type as [or(def("Expression"),
// null)], but null values don't really make sense at the call site.
// TODO Report this nonsense.
.field("arguments", [def("Expression")]);
def("CallExpression")
.bases("Expression")
.build("callee", "arguments")
.field("callee", def("Expression"))
// See comment for NewExpression above.
.field("arguments", [def("Expression")]);
def("MemberExpression")
.bases("Expression")
.build("object", "property", "computed")
.field("object", def("Expression"))
.field("property", or(def("Identifier"), def("Expression")))
.field("computed", Boolean, function () {
var type = this.property.type;
if (type === 'Literal' ||
type === 'MemberExpression' ||
type === 'BinaryExpression') {
return true;
}
return false;
});
def("Pattern").bases("Node");
def("SwitchCase")
.bases("Node")
.build("test", "consequent")
.field("test", or(def("Expression"), null))
.field("consequent", [def("Statement")]);
def("Identifier")
.bases("Expression", "Pattern")
.build("name")
.field("name", String)
.field("optional", Boolean, defaults["false"]);
def("Literal")
.bases("Expression")
.build("value")
.field("value", or(String, Boolean, null, Number, RegExp, BigInt));
// Abstract (non-buildable) comment supertype. Not a Node.
def("Comment")
.bases("Printable")
.field("value", String)
// A .leading comment comes before the node, whereas a .trailing
// comment comes after it. These two fields should not both be true,
// but they might both be false when the comment falls inside a node
// and the node has no children for the comment to lead or trail,
// e.g. { /*dangling*/ }.
.field("leading", Boolean, defaults["true"])
.field("trailing", Boolean, defaults["false"]);
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=core.js.map
/***/ }),
/***/ 3676:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var shared_1 = tslib_1.__importStar(__nccwpck_require__(4456));
var es2022_1 = tslib_1.__importDefault(__nccwpck_require__(7920));
function default_1(fork) {
fork.use(es2022_1.default);
var types = fork.use(types_1.default);
var Type = types.Type;
var def = types.Type.def;
var or = Type.or;
var shared = fork.use(shared_1.default);
var defaults = shared.defaults;
def("AwaitExpression")
.build("argument", "all")
.field("argument", or(def("Expression"), null))
.field("all", Boolean, defaults["false"]);
// Decorators
def("Decorator")
.bases("Node")
.build("expression")
.field("expression", def("Expression"));
def("Property")
.field("decorators", or([def("Decorator")], null), defaults["null"]);
def("MethodDefinition")
.field("decorators", or([def("Decorator")], null), defaults["null"]);
// Private names
def("PrivateName")
.bases("Expression", "Pattern")
.build("id")
.field("id", def("Identifier"));
def("ClassPrivateProperty")
.bases("ClassProperty")
.build("key", "value")
.field("key", def("PrivateName"))
.field("value", or(def("Expression"), null), defaults["null"]);
// https://github.com/tc39/proposal-import-assertions
def("ImportAttribute")
.bases("Node")
.build("key", "value")
.field("key", or(def("Identifier"), def("Literal")))
.field("value", def("Expression"));
["ImportDeclaration",
"ExportAllDeclaration",
"ExportNamedDeclaration",
].forEach(function (decl) {
def(decl).field("assertions", [def("ImportAttribute")], defaults.emptyArray);
});
// https://github.com/tc39/proposal-record-tuple
// https://github.com/babel/babel/pull/10865
def("RecordExpression")
.bases("Expression")
.build("properties")
.field("properties", [or(def("ObjectProperty"), def("ObjectMethod"), def("SpreadElement"))]);
def("TupleExpression")
.bases("Expression")
.build("elements")
.field("elements", [or(def("Expression"), def("SpreadElement"), null)]);
// https://github.com/tc39/proposal-js-module-blocks
// https://github.com/babel/babel/pull/12469
def("ModuleExpression")
.bases("Node")
.build("body")
.field("body", def("Program"));
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=es-proposals.js.map
/***/ }),
/***/ 5836:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var es2016_1 = tslib_1.__importDefault(__nccwpck_require__(5054));
var es6_1 = tslib_1.__importDefault(__nccwpck_require__(2719));
var shared_1 = __nccwpck_require__(4456);
function default_1(fork) {
// The es2016OpsDef plugin comes before es6Def so BinaryOperators and
// AssignmentOperators will be appropriately augmented before they are first
// used in the core definitions for this fork.
fork.use(es2016_1.default);
fork.use(es6_1.default);
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=es2016.js.map
/***/ }),
/***/ 3265:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var es2016_1 = tslib_1.__importDefault(__nccwpck_require__(5836));
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var shared_1 = tslib_1.__importStar(__nccwpck_require__(4456));
function default_1(fork) {
fork.use(es2016_1.default);
var types = fork.use(types_1.default);
var def = types.Type.def;
var defaults = fork.use(shared_1.default).defaults;
def("Function")
.field("async", Boolean, defaults["false"]);
def("AwaitExpression")
.bases("Expression")
.build("argument")
.field("argument", def("Expression"));
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=es2017.js.map
/***/ }),
/***/ 1619:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var es2017_1 = tslib_1.__importDefault(__nccwpck_require__(3265));
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var shared_1 = tslib_1.__importStar(__nccwpck_require__(4456));
function default_1(fork) {
fork.use(es2017_1.default);
var types = fork.use(types_1.default);
var def = types.Type.def;
var or = types.Type.or;
var defaults = fork.use(shared_1.default).defaults;
def("ForOfStatement")
.field("await", Boolean, defaults["false"]);
// Legacy
def("SpreadProperty")
.bases("Node")
.build("argument")
.field("argument", def("Expression"));
def("ObjectExpression")
.field("properties", [or(def("Property"), def("SpreadProperty"), // Legacy
def("SpreadElement"))]);
def("TemplateElement")
.field("value", { "cooked": or(String, null), "raw": String });
// Legacy
def("SpreadPropertyPattern")
.bases("Pattern")
.build("argument")
.field("argument", def("Pattern"));
def("ObjectPattern")
.field("properties", [or(def("PropertyPattern"), def("Property"), def("RestElement"), def("SpreadPropertyPattern"))]);
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=es2018.js.map
/***/ }),
/***/ 6653:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.nmd(module);
Object.defineProperty(exports, "__esModule", ({ value: true }));
var tslib_1 = __nccwpck_require__(204);
var es2018_1 = tslib_1.__importDefault(__nccwpck_require__(1619));
var types_1 = tslib_1.__importDefault(__nccwpck_require__(1018));
var shared_1 = tslib_1.__importStar(__nccwpck_require__(4456));
function default_1(fork) {
fork.use(es2018_1.default);
var types = fork.use(types_1.default);
var def = types.Type.def;
var or = types.Type.or;
var defaults = fork.use(shared_1.default).defaults;
def("CatchClause")
.field("param", or(def("Pattern"), null), defaults["null"]);
}
exports["default"] = default_1;
;
(0, shared_1.maybeSetModuleExports)(function () { return module; });
//# sourceMappingURL=es2019.js.map
/***/ }),
/***/ 26:
/***/ ((module, exports, __nccwpck_require__) => {
/* module decorator */ module = __nccwpck_require__.