weapp-tailwindcss
Version:
把 tailwindcss 原子化样式思想，带给小程序开发者们! bring tailwindcss to miniprogram developers!
1,638 lines • 1.25 MB
JavaScript
//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
var __exportAll = (all, no_symbols) => {
let target = {};
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
return target;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
key = keys[i];
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
get: ((k) => from[k]).bind(null, key),
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
//#endregion
let node_process = require("node:process");
node_process = __toESM(node_process, 1);
let semver = require("semver");
semver = __toESM(semver, 1);
let node_path = require("node:path");
node_path = __toESM(node_path, 1);
let node_fs_promises = require("node:fs/promises");
let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
let lru_cache = require("lru-cache");
let _weapp_tailwindcss_shared_node = require("@weapp-tailwindcss/shared/node");
let _weapp_core_escape = require("@weapp-core/escape");
require("@weapp-tailwindcss/shared");
let node_fs = require("node:fs");
node_fs = __toESM(node_fs, 1);
let debug = require("debug");
debug = __toESM(debug, 1);
let _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
let node_module = require("node:module");
require("micromatch");
require("fast-glob");
require("tailwindcss-config");
let node_tty = require("node:tty");
let node_util = require("node:util");
//#region src/js/babel/cache-options.ts
const DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH = 5e4;
const HARD_PARSE_CACHE_MAX_ENTRIES = 1024;
//#endregion
//#region src/debug/index.ts
const _debug = (0, debug.default)("weapp-tw");
function createDebug$2(prefix) {
const debug$4 = ((formatter, ...args) => {
return _debug((prefix ?? "") + formatter, ...args);
});
Object.defineProperty(debug$4, "enabled", {
enumerable: false,
configurable: false,
get() {
return _debug.enabled;
}
});
return debug$4;
}
//#endregion
//#region src/tailwindcss/v4-engine/generator/rpx-candidates.ts
const RPX_LENGTH_UTILITY_PATTERN = String.raw`text|border(?:-[trblxyse])?|bg|outline|ring`;
new RegExp(String.raw`(^|:)(!?)(${RPX_LENGTH_UTILITY_PATTERN})-\[([-+]?(?:\d+|\d*\.\d+)rpx)\](.*)$`, "u");
new RegExp(String.raw`(?:^|:)!?(${RPX_LENGTH_UTILITY_PATTERN})-\[length:([-+]?(?:\d+|\d*\.\d+)rpx)\].*$`, "u");
new RegExp(String.raw`(${RPX_LENGTH_UTILITY_PATTERN})-\\\[length\\:((?:\\[.+-]|[+\-.\d])+rpx)\\\]`, "g");
new lru_cache.LRUCache({ max: 8 });
new lru_cache.LRUCache({ max: 32 });
(0, _weapp_tailwindcss_postcss.createStyleHandler)({
cssChildCombinatorReplaceValue: ["view", "text"],
cssRemoveHoverPseudoClass: true,
isMainChunk: true,
majorVersion: 4
});
(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
//#endregion
//#region \0@oxc-project+runtime@0.140.0/helpers/esm/typeof.js
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
return typeof o;
} : function(o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
//#endregion
//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPrimitive.js
function toPrimitive(t, r) {
if ("object" != _typeof(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
//#endregion
//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPropertyKey.js
function toPropertyKey(t) {
var i = toPrimitive(t, "string");
return "symbol" == _typeof(i) ? i : i + "";
}
//#endregion
//#region \0@oxc-project+runtime@0.140.0/helpers/esm/defineProperty.js
function _defineProperty(e, r, t) {
return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: !0,
configurable: !0,
writable: !0
}) : e[r] = t, e;
}
//#endregion
//#region src/tailwindcss/source-scan.ts
const DEFAULT_SOURCE_SCAN_EXTENSIONS = [
"html",
"wxml",
"axml",
"jxml",
"ksml",
"ttml",
"qml",
"tyml",
"xhsml",
"swan",
"vue",
"mpx",
"js",
"jsx",
"ts",
"tsx"
];
const FULL_SOURCE_SCAN_EXTENSIONS = [
"js",
"jsx",
"mjs",
"cjs",
"ts",
"tsx",
"mts",
"cts",
"vue",
"uvue",
"nvue",
"svelte",
"mpx",
"html",
"wxml",
"axml",
"jxml",
"ksml",
"ttml",
"qml",
"tyml",
"xhsml",
"swan",
"css",
"wxss",
"acss",
"jxss",
"ttss",
"qss",
"tyss",
"scss",
"sass",
"less",
"styl",
"stylus"
];
function createSourceScanPattern(extensions = DEFAULT_SOURCE_SCAN_EXTENSIONS) {
return `**/*.{${extensions.join(",")}}`;
}
createSourceScanPattern(FULL_SOURCE_SCAN_EXTENSIONS);
new RegExp(`\\.(?:${FULL_SOURCE_SCAN_EXTENSIONS.map((extension) => extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`);
//#endregion
//#region src/utils/object.ts
function definedEntries(value) {
return Object.entries(value).filter(([, item]) => item !== void 0);
}
function omitUndefined(value) {
return Object.fromEntries(definedEntries(value));
}
(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
createDebug$2("[tailwindcss:runtime] ");
//#endregion
//#region src/tailwindcss/runtime-logs.ts
const runtimeLogDedupeHolder = globalThis;
runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ ?? (runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ = /* @__PURE__ */ new Set());
(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
const globalCacheHolder = globalThis;
globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
//#endregion
//#region ../../node_modules/.pnpm/obug@2.1.4/node_modules/obug/dist/core.js
/**
* Coerce `value`.
*/
function coerce(value) {
if (value instanceof Error) return value.stack || value.message;
return value;
}
/**
* Selects a color for a debug namespace
* @return An ANSI color code for the given namespace
*/
function selectColor(colors, namespace) {
let hash = 0;
for (let i = 0; i < namespace.length; i++) {
hash = (hash << 5) - hash + namespace.charCodeAt(i);
hash |= 0;
}
return colors[Math.abs(hash) % colors.length];
}
/**
* Checks if the given string matches a namespace template, honoring
* asterisks as wildcards.
*/
function matchesTemplate(search, template) {
let searchIndex = 0;
let templateIndex = 0;
let starIndex = -1;
let matchIndex = 0;
while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
starIndex = templateIndex;
matchIndex = searchIndex;
templateIndex++;
} else {
searchIndex++;
templateIndex++;
}
else if (starIndex !== -1) {
templateIndex = starIndex + 1;
matchIndex++;
searchIndex = matchIndex;
} else return false;
while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
return templateIndex === template.length;
}
function humanize(value) {
if (value >= 1e3) return `${(value / 1e3).toFixed(1)}s`;
return `${value}ms`;
}
let globalNamespaces = "";
function createDebug$1(namespace, options) {
let prevTime;
let enableOverride;
let namespacesCache;
let enabledCache;
const debug = (...args) => {
if (!debug.enabled) return;
const curr = Date.now();
const diff = curr - (prevTime || curr);
prevTime = curr;
args[0] = coerce(args[0]);
if (typeof args[0] !== "string") args.unshift("%O");
let index = 0;
args[0] = args[0].replace(/%([a-z%])/gi, (match, format) => {
if (match === "%%") return "%";
index++;
const formatter = options.formatters[format];
if (typeof formatter === "function") {
const value = args[index];
match = formatter.call(debug, value);
args.splice(index, 1);
index--;
}
return match;
});
options.formatArgs.call(debug, diff, args);
debug.log(...args);
};
debug.extend = function(namespace, delimiter = ":") {
return createDebug$1(this.namespace + delimiter + namespace, {
useColors: this.useColors,
color: this.color,
formatArgs: this.formatArgs,
formatters: this.formatters,
inspectOpts: this.inspectOpts,
log: this.log,
humanize: this.humanize
});
};
Object.assign(debug, options);
debug.namespace = namespace;
Object.defineProperty(debug, "enabled", {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride != null) return enableOverride;
if (namespacesCache !== globalNamespaces) {
namespacesCache = globalNamespaces;
enabledCache = enabled(namespace);
}
return enabledCache;
},
set: (v) => {
enableOverride = v;
}
});
return debug;
}
let names = [];
let skips = [];
function enable(namespaces) {
globalNamespaces = namespaces;
names = [];
skips = [];
const split = globalNamespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
for (const ns of split) if (ns[0] === "-") skips.push(ns.slice(1));
else names.push(ns);
}
/**
* Returns true if the given mode name is enabled, false otherwise.
*/
function enabled(name) {
for (const skip of skips) if (matchesTemplate(name, skip)) return false;
for (const ns of names) if (matchesTemplate(name, ns)) return true;
return false;
}
//#endregion
//#region ../../node_modules/.pnpm/obug@2.1.4/node_modules/obug/dist/node.js
let env = {};
try {
process.env.DEBUG;
env = process.env;
} catch (_unused) {}
const colors = process.stderr.getColorDepth && process.stderr.getColorDepth(env) > 2 ? [
20,
21,
26,
27,
32,
33,
38,
39,
40,
41,
42,
43,
44,
45,
56,
57,
62,
63,
68,
69,
74,
75,
76,
77,
78,
79,
80,
81,
92,
93,
98,
99,
112,
113,
128,
129,
134,
135,
148,
149,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
178,
179,
184,
185,
196,
197,
198,
199,
200,
201,
202,
203,
204,
205,
206,
207,
208,
209,
214,
215,
220,
221
] : [
6,
2,
3,
4,
5,
1
];
const inspectOpts = Object.keys(env).filter((key) => /^debug_/i.test(key)).reduce((obj, key) => {
const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase());
let value = env[key];
const lowerCase = typeof value === "string" && value.toLowerCase();
if (value === "null") value = null;
else if (lowerCase === "yes" || lowerCase === "on" || lowerCase === "true" || lowerCase === "enabled") value = true;
else if (lowerCase === "no" || lowerCase === "off" || lowerCase === "false" || lowerCase === "disabled") value = false;
else value = Number(value);
obj[prop] = value;
return obj;
}, Object.create(null));
/**
* Is stdout a TTY? Colored output is enabled when `true`.
*/
function useColors() {
return "colors" in inspectOpts ? Boolean(inspectOpts.colors) : (0, node_tty.isatty)(process.stderr.fd);
}
function getDate() {
if (inspectOpts.hideDate) return "";
return `${(/* @__PURE__ */ new Date()).toISOString()} `;
}
/**
* Adds ANSI color escape codes if enabled.
*/
function formatArgs(diff, args) {
const { namespace: name, useColors } = this;
if (useColors) {
const c = this.color;
const colorCode = `\u001B[3${c < 8 ? c : `8;5;${c}`}`;
const prefix = ` ${colorCode};1m${name} \u001B[0m`;
args[0] = prefix + args[0].split("\n").join(`\n${prefix}`);
args.push(`${colorCode}m+${this.humanize(diff)}\u001B[0m`);
} else args[0] = `${getDate()}${name} ${args[0]}`;
}
function log(...args) {
process.stderr.write(`${(0, node_util.formatWithOptions)(this.inspectOpts, ...args)}\n`);
}
const defaultOptions = {
useColors: useColors(),
formatArgs,
formatters: {
/**
* Map %o to `util.inspect()`, all on a single line.
*/
o(v) {
this.inspectOpts.colors = this.useColors;
return (0, node_util.inspect)(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
},
/**
* Map %O to `util.inspect()`, allowing multiple lines if needed.
*/
O(v) {
this.inspectOpts.colors = this.useColors;
return (0, node_util.inspect)(v, this.inspectOpts);
}
},
inspectOpts,
log,
humanize
};
function createDebug(namespace, options) {
var _ref;
const color = (_ref = options && options.color) !== null && _ref !== void 0 ? _ref : selectColor(colors, namespace);
return createDebug$1(namespace, Object.assign(defaultOptions, { color }, options));
}
enable(env.DEBUG || "");
//#endregion
//#region ../../node_modules/.pnpm/@babel+code-frame@8.0.0/node_modules/@babel/code-frame/lib/common-shared.js
const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
function getMarkerLines(loc, source, opts, startLineBaseZero) {
const startLoc = {
column: null,
line: -1,
...loc.start
};
const endLoc = {
...startLoc,
...loc.end
};
const { linesAbove = 2, linesBelow = 3 } = opts || {};
const startLine = startLoc.line - startLineBaseZero;
const startColumn = startLoc.column;
const endLine = endLoc.line - startLineBaseZero;
const endColumn = endLoc.column;
let start = Math.max(startLine - (linesAbove + 1), 0);
let end = Math.min(source.length, endLine + linesBelow);
if (startLine === -1) start = 0;
if (endLine === -1) end = source.length;
const lineDiff = endLine - startLine;
const markerLines = {};
if (lineDiff) for (let i = 0; i <= lineDiff; i++) {
const lineNumber = i + startLine;
if (startColumn == null) markerLines[lineNumber] = true;
else if (i === 0) markerLines[lineNumber] = [startColumn, source[lineNumber - 1].length - startColumn];
else if (i === lineDiff) markerLines[lineNumber] = [0, endColumn];
else markerLines[lineNumber] = [0, source[lineNumber - 1].length];
}
else if (startColumn === endColumn) if (startColumn != null) markerLines[startLine] = [startColumn, 0];
else markerLines[startLine] = true;
else {
const safeStart = startColumn ?? 0;
markerLines[startLine] = [safeStart, (endColumn ?? safeStart) - safeStart];
}
return {
start,
end,
markerLines
};
}
function _codeFrameColumns(rawLines, loc, opts = {}, colorOpts) {
const { defs, highlight } = colorOpts || {
defs: {
gutter: String,
marker: String,
message: String,
reset: String
},
highlight: String
};
const startLineBaseZero = (opts.startLine || 1) - 1;
const { start, end, markerLines } = getMarkerLines(loc, rawLines.split(NEWLINE$1), opts, startLineBaseZero);
const hasColumns = loc.start && typeof loc.start.column === "number";
const numberMaxWidth = String(end + startLineBaseZero).length;
let frame = highlight(rawLines).split(NEWLINE$1, end).slice(start, end).map((line, index) => {
const number = start + 1 + index;
const gutter = ` ${` ${number + startLineBaseZero}`.slice(-numberMaxWidth)} |`;
const hasMarker = markerLines[number];
const lastMarkerLine = !markerLines[number + 1];
if (hasMarker) {
let markerLine = "";
if (Array.isArray(hasMarker)) {
const markerSpacing = line.slice(0, hasMarker[0]).replace(/[^\t]/g, " ");
const numberOfMarkers = hasMarker[1] || 1;
markerLine = [
"\n ",
defs.gutter(gutter.replace(/\d/g, " ")),
" ",
markerSpacing,
defs.marker("^").repeat(numberOfMarkers)
].join("");
if (lastMarkerLine && opts.message) markerLine += " " + defs.message(opts.message);
}
return [
defs.marker(">"),
defs.gutter(gutter),
line.length > 0 ? ` ${line}` : "",
markerLine
].join("");
} else return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
}).join("\n");
if (opts.message && !hasColumns) frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
return defs.reset(frame);
}
//#endregion
//#region ../../node_modules/.pnpm/js-tokens@10.0.0/node_modules/js-tokens/index.js
var HashbangComment;
var Identifier$3;
var JSXIdentifier$2;
var JSXPunctuator;
var JSXString;
var JSXText$2;
var KeywordsWithExpressionAfter;
var KeywordsWithNoLineTerminatorAfter;
var LineTerminatorSequence;
var MultiLineComment;
var Newline;
var NumericLiteral$3;
var Punctuator;
var RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy;
var SingleLineComment;
var StringLiteral$3;
var Template;
var TokensNotPrecedingObjectLiteral;
var TokensPrecedingExpression;
var WhiteSpace;
var jsTokens;
Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
Identifier$3 = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy;
StringLiteral$3 = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
NumericLiteral$3 = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y;
WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy;
LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
SingleLineComment = /\/\/.*/y;
HashbangComment = /^#!.*/;
JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
JSXIdentifier$2 = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy;
JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
JSXText$2 = /[^<>{}]+/y;
TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
Newline = RegExp(LineTerminatorSequence.source);
jsTokens = function* (input, { jsx = false } = {}) {
var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
({length} = input);
lastIndex = 0;
lastSignificantToken = "";
stack = [{ tag: "JS" }];
braces = [];
parenNesting = 0;
postfixIncDec = false;
if (match = HashbangComment.exec(input)) {
yield {
type: "HashbangComment",
value: match[0]
};
lastIndex = match[0].length;
}
while (lastIndex < length) {
mode = stack[stack.length - 1];
switch (mode.tag) {
case "JS":
case "JSNonExpressionParen":
case "InterpolationInTemplate":
case "InterpolationInJSX":
if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
RegularExpressionLiteral.lastIndex = lastIndex;
if (match = RegularExpressionLiteral.exec(input)) {
lastIndex = RegularExpressionLiteral.lastIndex;
lastSignificantToken = match[0];
postfixIncDec = true;
yield {
type: "RegularExpressionLiteral",
value: match[0],
closed: match[1] !== void 0 && match[1] !== "\\"
};
continue;
}
}
Punctuator.lastIndex = lastIndex;
if (match = Punctuator.exec(input)) {
punctuator = match[0];
nextLastIndex = Punctuator.lastIndex;
nextLastSignificantToken = punctuator;
switch (punctuator) {
case "(":
if (lastSignificantToken === "?NonExpressionParenKeyword") stack.push({
tag: "JSNonExpressionParen",
nesting: parenNesting
});
parenNesting++;
postfixIncDec = false;
break;
case ")":
parenNesting--;
postfixIncDec = true;
if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
stack.pop();
nextLastSignificantToken = "?NonExpressionParenEnd";
postfixIncDec = false;
}
break;
case "{":
Punctuator.lastIndex = 0;
isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
braces.push(isExpression);
postfixIncDec = false;
break;
case "}":
switch (mode.tag) {
case "InterpolationInTemplate":
if (braces.length === mode.nesting) {
Template.lastIndex = lastIndex;
match = Template.exec(input);
lastIndex = Template.lastIndex;
lastSignificantToken = match[0];
if (match[1] === "${") {
lastSignificantToken = "?InterpolationInTemplate";
postfixIncDec = false;
yield {
type: "TemplateMiddle",
value: match[0]
};
} else {
stack.pop();
postfixIncDec = true;
yield {
type: "TemplateTail",
value: match[0],
closed: match[1] === "`"
};
}
continue;
}
break;
case "InterpolationInJSX": if (braces.length === mode.nesting) {
stack.pop();
lastIndex += 1;
lastSignificantToken = "}";
yield {
type: "JSXPunctuator",
value: "}"
};
continue;
}
}
postfixIncDec = braces.pop();
nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
break;
case "]":
postfixIncDec = true;
break;
case "++":
case "--":
nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
break;
case "<":
if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
stack.push({ tag: "JSXTag" });
lastIndex += 1;
lastSignificantToken = "<";
yield {
type: "JSXPunctuator",
value: punctuator
};
continue;
}
postfixIncDec = false;
break;
default: postfixIncDec = false;
}
lastIndex = nextLastIndex;
lastSignificantToken = nextLastSignificantToken;
yield {
type: "Punctuator",
value: punctuator
};
continue;
}
Identifier$3.lastIndex = lastIndex;
if (match = Identifier$3.exec(input)) {
lastIndex = Identifier$3.lastIndex;
nextLastSignificantToken = match[0];
switch (match[0]) {
case "for":
case "if":
case "while":
case "with": if (lastSignificantToken !== "." && lastSignificantToken !== "?.") nextLastSignificantToken = "?NonExpressionParenKeyword";
}
lastSignificantToken = nextLastSignificantToken;
postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
yield {
type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
value: match[0]
};
continue;
}
StringLiteral$3.lastIndex = lastIndex;
if (match = StringLiteral$3.exec(input)) {
lastIndex = StringLiteral$3.lastIndex;
lastSignificantToken = match[0];
postfixIncDec = true;
yield {
type: "StringLiteral",
value: match[0],
closed: match[2] !== void 0
};
continue;
}
NumericLiteral$3.lastIndex = lastIndex;
if (match = NumericLiteral$3.exec(input)) {
lastIndex = NumericLiteral$3.lastIndex;
lastSignificantToken = match[0];
postfixIncDec = true;
yield {
type: "NumericLiteral",
value: match[0]
};
continue;
}
Template.lastIndex = lastIndex;
if (match = Template.exec(input)) {
lastIndex = Template.lastIndex;
lastSignificantToken = match[0];
if (match[1] === "${") {
lastSignificantToken = "?InterpolationInTemplate";
stack.push({
tag: "InterpolationInTemplate",
nesting: braces.length
});
postfixIncDec = false;
yield {
type: "TemplateHead",
value: match[0]
};
} else {
postfixIncDec = true;
yield {
type: "NoSubstitutionTemplate",
value: match[0],
closed: match[1] === "`"
};
}
continue;
}
break;
case "JSXTag":
case "JSXTagEnd":
JSXPunctuator.lastIndex = lastIndex;
if (match = JSXPunctuator.exec(input)) {
lastIndex = JSXPunctuator.lastIndex;
nextLastSignificantToken = match[0];
switch (match[0]) {
case "<":
stack.push({ tag: "JSXTag" });
break;
case ">":
stack.pop();
if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
nextLastSignificantToken = "?JSX";
postfixIncDec = true;
} else stack.push({ tag: "JSXChildren" });
break;
case "{":
stack.push({
tag: "InterpolationInJSX",
nesting: braces.length
});
nextLastSignificantToken = "?InterpolationInJSX";
postfixIncDec = false;
break;
case "/": if (lastSignificantToken === "<") {
stack.pop();
if (stack[stack.length - 1].tag === "JSXChildren") stack.pop();
stack.push({ tag: "JSXTagEnd" });
}
}
lastSignificantToken = nextLastSignificantToken;
yield {
type: "JSXPunctuator",
value: match[0]
};
continue;
}
JSXIdentifier$2.lastIndex = lastIndex;
if (match = JSXIdentifier$2.exec(input)) {
lastIndex = JSXIdentifier$2.lastIndex;
lastSignificantToken = match[0];
yield {
type: "JSXIdentifier",
value: match[0]
};
continue;
}
JSXString.lastIndex = lastIndex;
if (match = JSXString.exec(input)) {
lastIndex = JSXString.lastIndex;
lastSignificantToken = match[0];
yield {
type: "JSXString",
value: match[0],
closed: match[2] !== void 0
};
continue;
}
break;
case "JSXChildren":
JSXText$2.lastIndex = lastIndex;
if (match = JSXText$2.exec(input)) {
lastIndex = JSXText$2.lastIndex;
lastSignificantToken = match[0];
yield {
type: "JSXText",
value: match[0]
};
continue;
}
switch (input[lastIndex]) {
case "<":
stack.push({ tag: "JSXTag" });
lastIndex++;
lastSignificantToken = "<";
yield {
type: "JSXPunctuator",
value: "<"
};
continue;
case "{":
stack.push({
tag: "InterpolationInJSX",
nesting: braces.length
});
lastIndex++;
lastSignificantToken = "?InterpolationInJSX";
postfixIncDec = false;
yield {
type: "JSXPunctuator",
value: "{"
};
continue;
}
}
WhiteSpace.lastIndex = lastIndex;
if (match = WhiteSpace.exec(input)) {
lastIndex = WhiteSpace.lastIndex;
yield {
type: "WhiteSpace",
value: match[0]
};
continue;
}
LineTerminatorSequence.lastIndex = lastIndex;
if (match = LineTerminatorSequence.exec(input)) {
lastIndex = LineTerminatorSequence.lastIndex;
postfixIncDec = false;
if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere";
yield {
type: "LineTerminatorSequence",
value: match[0]
};
continue;
}
MultiLineComment.lastIndex = lastIndex;
if (match = MultiLineComment.exec(input)) {
lastIndex = MultiLineComment.lastIndex;
if (Newline.test(match[0])) {
postfixIncDec = false;
if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere";
}
yield {
type: "MultiLineComment",
value: match[0],
closed: match[1] !== void 0
};
continue;
}
SingleLineComment.lastIndex = lastIndex;
if (match = SingleLineComment.exec(input)) {
lastIndex = SingleLineComment.lastIndex;
postfixIncDec = false;
yield {
type: "SingleLineComment",
value: match[0]
};
continue;
}
firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
lastIndex += firstCodePoint.length;
lastSignificantToken = firstCodePoint;
postfixIncDec = false;
yield {
type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
value: firstCodePoint
};
}
};
var js_tokens_default = jsTokens;
//#endregion
//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.4/node_modules/@babel/helper-validator-identifier/lib/identifier.js
const bmpIdentifierStart$1 = /[\p{ID_Start}\u088f\u0c5c\u0cdc\ua7ce\ua7cf\ua7d2\ua7d4\ua7f1]/u;
const bmpIdentifier$1 = /[\p{ID_Continue}\u088f\u0c5c\u0cdc\ua7ce\ua7cf\ua7d2\ua7d4\ua7f1\u1acf-\u1add\u1ae0-\u1aeb]/u;
const supplementaryIdentifierStartCodes$1 = [
2368,
25,
1388,
2,
3817,
43,
20677,
24,
3,
24,
287,
4,
6146,
7,
1290,
21,
98,
114,
22734,
30,
2,
2,
2,
1,
2,
6,
3,
4,
10,
1,
53307,
5,
5987,
11,
21763,
4297
];
const supplementaryIdentifierCodes$1 = [
3834,
1,
3173,
7,
633,
9,
51450,
0,
3,
0,
8,
1,
6,
0
];
function isInSupplementarySet$1(code, set) {
let pos = 65536;
for (let i = 0, length = set.length; i < length; i += 2) {
pos += set[i];
if (pos > code) return false;
pos += set[i + 1];
if (pos >= code) return true;
}
return false;
}
function isIdentifierStart$1(code) {
if (code < 65) return code === 36;
if (code <= 90) return true;
if (code < 97) return code === 95;
if (code <= 122) return true;
if (code <= 65535) return code >= 170 && bmpIdentifierStart$1.test(String.fromCharCode(code));
return !isNaN(code) && code <= 1114111 && (bmpIdentifierStart$1.test(String.fromCodePoint(code)) || isInSupplementarySet$1(code, supplementaryIdentifierStartCodes$1));
}
function isIdentifierChar$1(code) {
if (code < 48) return code === 36;
if (code < 58) return true;
if (code < 65) return false;
if (code <= 90) return true;
if (code < 97) return code === 95;
if (code <= 122) return true;
if (code <= 65535) return code >= 170 && bmpIdentifier$1.test(String.fromCharCode(code));
return !isNaN(code) && code <= 1114111 && (bmpIdentifier$1.test(String.fromCodePoint(code)) || isInSupplementarySet$1(code, supplementaryIdentifierStartCodes$1) || isInSupplementarySet$1(code, supplementaryIdentifierCodes$1));
}
function isIdentifierName(name) {
let isFirst = true;
for (let i = 0; i < name.length; i++) {
let cp = name.charCodeAt(i);
if ((cp & 64512) === 55296 && i + 1 < name.length) {
const trail = name.charCodeAt(++i);
if ((trail & 64512) === 56320) cp = 65536 + ((cp & 1023) << 10) + (trail & 1023);
}
if (isFirst) {
isFirst = false;
if (!isIdentifierStart$1(cp)) return false;
} else if (!isIdentifierChar$1(cp)) return false;
}
return !isFirst;
}
//#endregion
//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.4/node_modules/@babel/helper-validator-identifier/lib/index.js
const reservedWords$1 = {
keyword: [
"break",
"case",
"catch",
"continue",
"debugger",
"default",
"do",
"else",
"finally",
"for",
"function",
"if",
"return",
"switch",
"throw",
"try",
"var",
"const",
"while",
"with",
"new",
"this",
"super",
"class",
"extends",
"export",
"import",
"null",
"true",
"false",
"in",
"instanceof",
"typeof",
"void",
"delete"
],
strict: [
"implements",
"interface",
"let",
"package",
"private",
"protected",
"public",
"static",
"yield"
],
strictBind: ["eval", "arguments"]
};
const keywords$2 = new Set(reservedWords$1.keyword);
const reservedWordsStrictSet$1 = new Set(reservedWords$1.strict);
new Set(reservedWords$1.strictBind);
function isReservedWord$1(word, inModule) {
return inModule && word === "await" || word === "enum";
}
function isStrictReservedWord$1(word, inModule) {
return isReservedWord$1(word, inModule) || reservedWordsStrictSet$1.has(word);
}
function isKeyword$1(word) {
return keywords$2.has(word);
}
//#endregion
//#region ../../node_modules/.pnpm/@babel+code-frame@8.0.0/node_modules/@babel/code-frame/lib/index.js
function isColorSupported() {
return (0, node_util.styleText)("red", "-") !== "-";
}
function createFormatter(format) {
return (input) => (0, node_util.styleText)(format, String(input ?? ""), { validateStream: false });
}
const defs = {
keyword: createFormatter("cyan"),
capitalized: createFormatter("yellow"),
jsxIdentifier: createFormatter("yellow"),
punctuator: createFormatter("yellow"),
number: createFormatter("magenta"),
string: createFormatter("green"),
regex: createFormatter("magenta"),
comment: createFormatter("gray"),
invalid: createFormatter([
"white",
"bgRed",
"bold"
]),
gutter: createFormatter("gray"),
marker: createFormatter(["red", "bold"]),
message: createFormatter(["red", "bold"]),
reset: createFormatter("reset")
};
const sometimesKeywords = /* @__PURE__ */ new Set([
"as",
"async",
"from",
"get",
"of",
"set"
]);
const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
const BRACKET = /^[()[\]{}]$/;
const getTokenType = function(token) {
if (token.type === "IdentifierName") {
const tokenValue = token.value;
if (isKeyword$1(tokenValue) || isStrictReservedWord$1(tokenValue, true) || sometimesKeywords.has(tokenValue)) return "keyword";
const firstChar = tokenValue.charCodeAt(0);
if (firstChar < 128) {
if (firstChar >= 65 && firstChar <= 90) return "capitalized";
} else {
const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
if (firstChar !== firstChar.toLowerCase()) return "capitalized";
}
}
if (token.type === "Punctuator" && BRACKET.test(token.value)) return "uncolored";
if (token.type === "Invalid" && token.value === "@") return "punctuator";
switch (token.type) {
case "NumericLiteral": return "number";
case "StringLiteral":
case "JSXString":
case "NoSubstitutionTemplate": return "string";
case "RegularExpressionLiteral": return "regex";
case "Punctuator":
case "JSXPunctuator": return "punctuator";
case "MultiLineComment":
case "SingleLineComment": return "comment";
case "Invalid":
case "JSXInvalid": return "invalid";
case "JSXIdentifier": return "jsxIdentifier";
default: return "uncolored";
}
};
function* tokenize(text) {
for (const token of js_tokens_default(text, { jsx: true })) switch (token.type) {
case "TemplateHead":
yield {
type: "string",
value: token.value.slice(0, -2)
};
yield {
type: "punctuator",
value: "${"
};
break;
case "TemplateMiddle":
yield {
type: "punctuator",
value: "}"
};
yield {
type: "string",
value: token.value.slice(1, -2)
};
yield {
type: "punctuator",
value: "${"
};
break;
case "TemplateTail":
yield {
type: "punctuator",
value: "}"
};
yield {
type: "string",
value: token.value.slice(1)
};
break;
default: yield {
type: getTokenType(token),
value: token.value
};
}
}
function highlight(text) {
if (text === "") return "";
let highlighted = "";
for (const { type, value } of tokenize(text)) if (type in defs) highlighted += value.split(NEWLINE).map((str) => defs[type](str)).join("\n");
else highlighted += value;
return highlighted;
}
function codeFrameColumns(rawLines, loc, opts = {}) {
return _codeFrameColumns(rawLines, loc, opts, opts.forceColor || isColorSupported() && opts.highlightCode ? {
defs,
highlight
} : void 0);
}
//#endregion
//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0/node_modules/@babel/helper-string-parser/lib/index.js
var _isDigit$1 = function isDigit(code) {
return code >= 48 && code <= 57;
};
const forbiddenNumericSeparatorSiblings$1 = {
decBinOct: /* @__PURE__ */ new Set([
46,
66,
69,
79,
95,
98,
101,
111
]),
hex: /* @__PURE__ */ new Set([
46,
88,
95,
120
])
};
const isAllowedNumericSeparatorSibling$1 = {
bin: (ch) => ch === 48 || ch === 49,
oct: (ch) => ch >= 48 && ch <= 55,
dec: (ch) => ch >= 48 && ch <= 57,
hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
};
function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
const initialPos = pos;
const initialLineStart = lineStart;
const initialCurLine = curLine;
let out = "";
let firstInvalidLoc = null;
let chunkStart = pos;
const { length } = input;
for (;;) {
if (pos >= length) {
errors.unterminated(initialPos, initialLineStart, initialCurLine);
out += input.slice(chunkStart, pos);
break;
}
const ch = input.charCodeAt(pos);
if (isStringEnd$1(type, ch, input, pos)) {
out += input.slice(chunkStart, pos);
break;
}
if (ch === 92) {
out += input.slice(chunkStart, pos);
const res = readEscapedChar$1(input, pos, lineStart, curLine, type === "template", errors);
if (res.ch === null && !firstInvalidLoc) firstInvalidLoc = {
pos,
lineStart,
curLine
};
else out += res.ch;
({pos, lineStart, curLine} = res);
chunkStart = pos;
} else if (ch === 8232 || ch === 8233) {
++pos;
++curLine;
lineStart = pos;
} else if (ch === 10 || ch === 13) if (type === "template") {
out += input.slice(chunkStart, pos) + "\n";
++pos;
if (ch === 13 && input.charCodeAt(pos) === 10) ++pos;
++curLine;
chunkStart = lineStart = pos;
} else errors.unterminated(initialPos, initialLineStart, initialCurLine);
else ++pos;
}
return {
pos,
str: out,
firstInvalidLoc,
lineStart,
curLine
};
}
function isStringEnd$1(type, ch, input, pos) {
if (type === "template") return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
return ch === (type === "double" ? 34 : 39);
}
function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
const throwOnInvalid = !inTemplate;
pos++;
const res = (ch) => ({
pos,
ch,
lineStart,
curLine
});
const ch = input.charCodeAt(pos++);
switch (ch) {
case 110: return res("\n");
case 114: return res("\r");
case 120: {
let code;
({code, pos} = readHexChar$1(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
return res(code === null ? null : String.fromCharCode(code));
}
case 117: {
let code;
({code, pos} = readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors));
return res(code === null ? null : String.fromCodePoint(code));
}
case 116: return res(" ");
case 98: return res("\b");
case 118: return res("\v");
case 102: return res("\f");
case 13: if (input.charCodeAt(pos) === 10) ++pos;
case 10:
lineStart = pos;
++curLine;
case 8232:
case 8233: return res("");
case 56:
case 57: if (inTemplate) return res(null);
else errors.strictNumericEscape(pos - 1, lineStart, curLine);
default:
if (ch >= 48 && ch <= 55) {
const startPos = pos - 1;
let octalStr = /^[0-7]+/.exec(input.slice(startPos, pos + 2))[0];
let octal = parseInt(octalStr, 8);
if (octal > 255) {
octalStr = octalStr.slice(0, -1);
octal = parseInt(octalStr, 8);
}
pos += octalStr.length - 1;
const next = input.charCodeAt(pos);
if (octalStr !== "0" || next === 56 || next === 57) if (inTemplate) return res(null);
else errors.strictNumericEscape(startPos, lineStart, curLine);
return res(String.fromCharCode(octal));
}
return res(String.fromCharCode(ch));
}
}
function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
const initialPos = pos;
let n;
({n, pos} = readInt$1(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
if (n === null) if (throwOnInvalid) errors.invalidEscapeSequence(initialPos, lineStart, curLine);
else pos = initialPos - 1;
return {
code: n,
pos
};
}
function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
const start = pos;
const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$1.hex : forbiddenNumericSeparatorSiblings$1.decBinOct;
const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$1.hex : radix === 10 ? isAllowedNumericSeparatorSibling$1.dec : radix === 8 ? isAllowedNumericSeparatorSibling$1.oct : isAllowedNumericSeparatorSibling$1.bin;
let invalid = false;
let total = 0;
for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
const code = input.charCodeAt(pos);
let val;
if (code === 95 && allowNumSeparator !== "bail") {
const prev = input.charCodeAt(pos - 1);
const next = input.charCodeAt(pos + 1);
if (!allowNumSeparator) {
if (bailOnError) return {
n: null,
pos
};
errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
} else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
if (bailOnError) return {
n: null,
pos
};
errors.unexpectedNumericSeparator(pos, lineStart, curLine);
}
++pos;
continue;
}
if (code >= 97) val = code - 97 + 10;
else if (code >= 65) val = code - 65 + 10;
else if (_isDigit$1(code)) val = code - 48;
else val = Infinity;
if (val >= radix) if (val <= 9 && bailOnError) return {
n: null,
pos
};
else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) val = 0;
else if (forceLen) {
val = 0;
invalid = true;
} else break;
++pos;
total = total * radix + val;
}
if (pos === start || len != null && pos - start !== len || invalid) return {
n: null,
pos
};
return {
n: total,
pos
};
}
function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors) {
const ch = input.charCodeAt(pos);
let code;
if (ch === 123) {
++pos;
({code, pos} = readHexChar$1(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
++pos;
if (code !== null && code > 1114111) if (throwOnInvalid) errors.invalidCodePoint(pos, lineStart, curLine);
else return {
code: null,
pos
};
} else ({code, pos} = readHexChar$1(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
return {
code,
pos
};
}
//#endregion
//#region ../../node_modules/.pnpm/@babel+types@8.0.4/node_modules/@babel/types/lib/index.js
var lib_exports = /* @__PURE__ */ __exportAll({
ACCESSOR_TYPES: () => ACCESSOR_TYPES,
ALIAS_KEYS: () => ALIAS_KEYS,
ASSIGNMENT_OPERATORS: () => ASSIGNMENT_OPERATORS,
AnyTypeAnnotation: () => AnyTypeAnnotation$1,
ArgumentPlaceholder: () => ArgumentPlaceholder$1,
ArrayExpression: () => ArrayExpression$2,
ArrayPattern: () => ArrayPattern,
ArrayTypeAnnotation: () => ArrayTypeAnnotation$1,
ArrowFunctionExpression: () => ArrowFunctionExpression$1,
AssignmentExpression: () => AssignmentExpression$3,
AssignmentPattern: () => AssignmentPattern$1,
AwaitExpression: () => AwaitExpression$1,
BINARY_OPERATORS: () => BINARY_OPERATORS,
BINARY_TYPES: () => BINARY_TYPES,
BLOCKPARENT_TYPES: () => BLOCKPARENT_TYPES,
BLOCK_TYPES: () => BLOCK_TYPES,
BOOLEAN_BINARY_OPERATORS: () => BOOLEAN_BINARY_OPERATORS$1,
BOOLEAN_NUMBER_BINARY_OPERATORS: () => BOOLEAN_NUMBER_BINARY_OPERATORS$1,
BOOLEAN_UNARY_OPERATORS: () => BOOLEAN_UNARY_OPERATORS$1,
BUILDER_KEYS: () => BUILDER_KEYS,
BigIntLiteral: () => BigIntLiteral$1,
BigIntLiteralTypeAnnotation: () => BigIntLiteralTypeAnnotation,
BinaryExpression: () => BinaryExpression$3,
BindExpression: () => BindExpression$1,
BlockStatement: () => BlockStatement$1,
BooleanLiteral: () => BooleanLiteral$2,
BooleanLiteralTypeAnnotation: () => BooleanLiteralTypeAnnotation$1,
BooleanTypeAnnotation: () => BooleanTypeAnnotation$1,
BreakStatement: () => BreakStatement$1,
CLASS_TYPES: () => CLASS_TYPES,
COMMENT_KEYS: () => COMMENT_KEYS,
COMPARISON_BINARY_OPERATORS: () => COMPARISON_BINARY_OPERATORS,
COMPLETIONSTATEMENT_TYPES: () => COMPLETIONSTATEMENT_TYPES,
CONDITIONAL_TYPES: () => CONDITIONAL_TYPES,
CallExpression: () => CallExpression$2,
CatchClause: () => CatchClause$1,
ClassAccessorProperty: () => ClassAccessorProperty$1,
ClassBody: () => ClassBody$1,
ClassDeclaration: () => ClassDeclaration$1,
ClassExpression: () => ClassExpression$1,
ClassImplements: () => ClassImplements,
ClassMethod: () => ClassMethod$1,
ClassPrivateMethod: () => ClassPrivateMethod$1,
ClassPrivateProperty: () => ClassPrivateProperty$1,
ClassProperty: () => ClassProperty$1,
ConditionalExpression: () => ConditionalExpression$3,
ContinueStatement: () => ContinueStatement$1,
DECLARATION_TYPES: () => DECLARATION_TYPES,
DEPRECATED_ALIASES: () => DEPRECATED_ALIASES$1,
DEPRECATED_KEYS: () => DEPRECATED_KEYS$1,
DebuggerStatement: () => DebuggerStatement$1,
DeclareClass: () => DeclareClass$1,
DeclareExportAllDeclaration: () => DeclareExportAllDeclaration$1,
DeclareExportDeclaration: () => DeclareExportDeclaration$1,
DeclareFunction: () => DeclareFunction$1,
DeclareInterface: () => DeclareInterface$1,
DeclareModule: () => DeclareModule$1,
DeclareModuleExports: () => DeclareModuleExports$1,
DeclareOpaqueType: () => DeclareOpaqueType$1,
DeclareTypeAlias: () => DeclareTypeAlias$1,
DeclareVariable: () => DeclareVariable$1,
DeclaredPredicate: () => DeclaredPredicate$1,
Decorator: () => Decorator$1,
Directive: () => Directive$1,
DirectiveLiteral: () => DirectiveLiteral$1,
DoExpression: () => DoExpression$2,
DoWhileStatement: () => DoWhileStatement$1,
ENUMBODY_TYPES: () => ENUMBODY_TYPES,
ENUMMEMBER_TYPES: () => ENUMMEMBER_TYPES,
EQUALITY_BINARY_OPERATORS: () => EQUALITY_BINARY_OPERATORS,
EXPORTDECLARATION_TYPES: () => EXPORTDECLARATION_TYPES,
EXPRESSIONWRAPPER_TYPES: () => EXPRESSIONWRAPPER_TYPES,
EXPRESSION_TYPES: () => EXPRESSION_TYPES,
EmptyStatement: () => EmptyStatement$1,
EmptyTypeAnnotation: () => EmptyTypeAnnotation$1,
EnumBooleanBody: () => EnumBooleanBody$1,
EnumBooleanMember: () => EnumBooleanMember$1,
EnumDeclaration: () => EnumDeclaration$1,
EnumDefaultedMember: () => EnumDefaultedMember$1,
EnumNumberBody: () => EnumNumberBody$1,
EnumNumberMember: () => EnumNumberMember$1,
EnumStringBody: () => EnumStringBody$1,
EnumStringMember: () => EnumStringMember$1,
EnumSymbolBody: () => EnumSymbolBody$1,
ExistsTypeAnnotation: () => ExistsTypeAnnotation$1,
ExportAllDeclaration: () => ExportAllDeclaration$1,
ExportDefaultDeclaration: () => ExportDefaultDeclaration$1,
ExportDefaultSpecifier: () => ExportDefaultSpecifier$1,
ExportNamedDeclaration: () => ExportNamedDeclaration$1,
ExportNamespaceSpecifier: () => ExportNamespaceSpecifier$1,
ExportSpecifier: () => ExportSpecifier$1,
ExpressionStatement: () => ExpressionStatement$1,
FLATTENABLE_KEYS: () => FLATTENABLE_KEYS,
FLIPPED_ALIAS_KEYS: () => FLIPPED_ALIAS_KEYS$1,
FLOWBASEANNOTATION_TYPES: () => FLOWBASEANNOTATION_TYPES,
FLOWDECLARATION_TYPES: () => FLOWDECLARATION_TYPES,
FLOWPREDICATE_TYPES: () => FLOWPREDICATE_TYPES,
FLOWTYPE_TYPES: () => FLOWTYPE_TYPES,
FLOW_TYPES: () => FLOW_TYPES,
FORXSTATEMENT_TYPES: () => FORXSTATEMENT_TYPES,
FOR_INIT_KEYS: () => FOR_INIT_KEYS,
FOR_TYPES: () => FOR_TYPES,
FUNCTIONPARAMETER_TYPES: () => FUNCTIONPARAMETER_TYPES,
FUNCTIONPARENT_TYPES: () => FUNCTIONPARENT_TYPES,
FUNCTION_TYPES: () => FUNCTION_TYPES$1,
File: () => File$1,
ForInStatement: () => ForInStatement$1,
ForOfStatement: () => ForOfStatement$1,
ForStatement: () => ForStatement$1,
FunctionDeclaration: () => FunctionDeclaration,
FunctionExpression: () => FunctionExpression$2,
FunctionTypeAnnotation: () => FunctionTypeAnnotation$2,
FunctionTypeParam: () => FunctionTypeParam$1,
GenericTypeAnnotation: () => GenericTypeAnnotation,
IMMUTABLE_TYPES: () => IMMUTABLE_TYPES,
IMPORTOREXPORTDECLARATION_TYPES: () => IMPORTOREXPORTDECLARATION_TYPES,
INHERIT_KEYS: () => INHERIT_KEYS,
Identifier: () => Identifier$2,
IfStatement: () => IfStatement$1,
Import: () => Import$1,
ImportAttribute: () => ImportAttribute$1,
ImportDeclaration: () => ImportDeclaration$1,
ImportDefaultSpecifier: () => ImportDefaultSpecifier$1,
ImportExpression: () => ImportExpression$1,
ImportNamespaceSpecifier: () => ImportNamespaceSpecifier$1,
ImportSpecifier: () => ImportSpecifier$1,
IndexedAccessType: () => IndexedAccessType$1,
InferredPredicate: () => InferredPredicate$1,
InterfaceDeclaration: () => InterfaceDeclaration$1,
InterfaceExtends: () => InterfaceExtends$1,
InterfaceTypeAnnotation: () => InterfaceTypeAnnotation$1,
InterpreterDirective: () => InterpreterDirective$1,
IntersectionTypeAnnotation: () => IntersectionTypeAnnotation$1,
JSXAttribute: () => JSXAttribute$1,
JSXClosingElement: () => JSXClosingElement$1,
JSXClosingFragment: () => JSXClosingFragment$1,
JSXElement: () => JSXElement$1,
JSXEmptyExpression: () => JSXEmptyExpression$1,
JSXExpressionContainer: () => JSXExpressionContainer$1,
JSXFragment: () => JSXFragment$1,
JSXIdentifier: () => JSXIdentifier$1,
JSXMemberExpression: () => JSXMemberExpression$1,
JSXNamespacedName: () => JSXNamespacedName$1,
JSXOpeningElement: () => JSXOpeningElement$1,
JSXOpeningFragment: () => JSXOpeningFragment$1,
JSXSpreadAttribute: () => JSXSpreadAttribute$1,
JSXSpreadChild: () => JSXSpreadChild$1,
JSXText: () => JSXText$1,
JSX_TYPES: () => JSX_TYPES,
LITERAL_TYPES: () => LITERAL_TYPES,
LOGICAL_OPERATORS: () => LOGICAL_OPERATORS$1