svgedit
Version:
Powerful SVG-Editor for your browser
2,323 lines (2,304 loc) • 166 kB
JavaScript
import { types, template } from '@babel/core';
import assert from 'node:assert';
const apiPolyfills = {
assertVersion: api => range => {
throwVersionError(range, api.version);
}
};
function declare(builder) {
return (api, options, dirname) => {
let clonedApi;
for (const name of Object.keys(apiPolyfills)) {
if (api[name]) continue;
clonedApi ??= copyApiObject(api);
clonedApi[name] = apiPolyfills[name](clonedApi);
}
return builder(clonedApi ?? api, options || {}, dirname);
};
}
function copyApiObject(api) {
let proto = null;
if (typeof api.version === "string" && api.version.startsWith("7.")) {
proto = Object.getPrototypeOf(api);
if (proto && (!Object.hasOwn(proto, "version") || !Object.hasOwn(proto, "transform") || !Object.hasOwn(proto, "template") || !Object.hasOwn(proto, "types"))) {
proto = null;
}
}
return {
...proto,
...api
};
}
function throwVersionError(range, version) {
if (typeof range === "number") {
if (!Number.isInteger(range)) {
throw new Error("Expected string or integer value.");
}
range = `^${range}.0.0-0`;
}
if (typeof range !== "string") {
throw new Error("Expected string or integer value.");
}
const limit = Error.stackTraceLimit;
if (typeof limit === "number" && limit < 25) {
Error.stackTraceLimit = 25;
}
let err;
if (version.startsWith("7.")) {
err = new Error(`Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` + `You'll need to update your @babel/core version.`);
} else {
err = new Error(`Requires Babel "${range}", but was loaded with "${version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
}
if (typeof limit === "number") {
Error.stackTraceLimit = limit;
}
throw Object.assign(err, {
code: "BABEL_VERSION_UNSUPPORTED",
version,
range
});
}
const jsx = declare(api => {
api.assertVersion("^7.0.0-0 || ^8.0.0");
return {
name: "syntax-jsx",
manipulateOptions(opts, parserOpts) {
parserOpts.plugins.push("jsx");
}
};
});
function shallowEqual(actual, expected) {
const keys = Object.keys(expected);
for (const key of keys) {
if (actual[key] !== expected[key]) {
return false;
}
}
return true;
}
function isFile(node, opts) {
if (!node) return false;
if (node.type !== "File") return false;
return opts == null || shallowEqual(node, opts);
}
function isIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "Identifier") return false;
return opts == null;
}
function isImportDeclaration$1(node, opts) {
if (!node) return false;
if (node.type !== "ImportDeclaration") return false;
return opts == null;
}
function isType(nodeType, targetType) {
if (nodeType === targetType) return true;
if (nodeType == null) return false;
if (ALIAS_KEYS[targetType]) return false;
const aliases = FLIPPED_ALIAS_KEYS[targetType];
if (aliases?.includes(nodeType)) return true;
return false;
}
function isPlaceholderType(placeholderType, targetType) {
if (placeholderType === targetType) return true;
const aliases = PLACEHOLDERS_ALIAS[placeholderType];
if (aliases?.includes(targetType)) return true;
return false;
}
function is(type, node, opts) {
if (!node) return false;
const matches = isType(node.type, type);
if (!matches) {
if (!opts && node.type === "Placeholder" && type in FLIPPED_ALIAS_KEYS) {
return isPlaceholderType(node.expectedNode, type);
}
return false;
}
if (opts === undefined) {
return true;
} else {
return shallowEqual(node, opts);
}
}
const bmpIdentifierStartChars = "\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u0870-\\u0887\\u0889-\\u088f\\u08a0-\\u08c9\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c5c\\u0c5d\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cdc-\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u1711\\u171f-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4c\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c8a\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7dc\\ua7f1-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab69\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc";
const bmpIdentifierChars = "\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u0897-\\u089f\\u08ca-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b55-\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3c\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0cf3\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d81-\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ece\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1715\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u180f-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf-\\u1add\\u1ae0-\\u1aeb\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1dff\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\u30fb\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua82c\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\\uff65";
const supplementaryIdentifierStartCodes = [
0,
11,
2,
25,
2,
18,
2,
1,
2,
14,
3,
13,
35,
122,
70,
52,
268,
28,
4,
48,
48,
31,
14,
29,
6,
37,
11,
29,
3,
35,
5,
7,
2,
4,
43,
157,
19,
35,
5,
35,
5,
39,
9,
51,
13,
10,
2,
14,
2,
6,
2,
1,
2,
10,
2,
14,
2,
6,
2,
1,
4,
51,
13,
310,
10,
21,
11,
7,
25,
5,
2,
41,
2,
8,
70,
5,
3,
0,
2,
43,
2,
1,
4,
0,
3,
22,
11,
22,
10,
30,
66,
18,
2,
1,
11,
21,
11,
25,
7,
25,
39,
55,
7,
1,
65,
0,
16,
3,
2,
2,
2,
28,
43,
28,
4,
28,
36,
7,
2,
27,
28,
53,
11,
21,
11,
18,
14,
17,
111,
72,
56,
50,
14,
50,
14,
35,
39,
27,
10,
22,
251,
41,
7,
1,
17,
5,
57,
28,
11,
0,
9,
21,
43,
17,
47,
20,
28,
22,
13,
52,
58,
1,
3,
0,
14,
44,
33,
24,
27,
35,
30,
0,
3,
0,
9,
34,
4,
0,
13,
47,
15,
3,
22,
0,
2,
0,
36,
17,
2,
24,
20,
1,
64,
6,
2,
0,
2,
3,
2,
14,
2,
9,
8,
46,
39,
7,
3,
1,
3,
21,
2,
6,
2,
1,
2,
4,
4,
0,
19,
0,
13,
4,
31,
9,
2,
0,
3,
0,
2,
37,
2,
0,
26,
0,
2,
0,
45,
52,
19,
3,
21,
2,
31,
47,
21,
1,
2,
0,
185,
46,
42,
3,
37,
47,
21,
0,
60,
42,
14,
0,
72,
26,
38,
6,
186,
43,
117,
63,
32,
7,
3,
0,
3,
7,
2,
1,
2,
23,
16,
0,
2,
0,
95,
7,
3,
38,
17,
0,
2,
0,
29,
0,
11,
39,
8,
0,
22,
0,
12,
45,
20,
0,
19,
72,
200,
32,
32,
8,
2,
36,
18,
0,
50,
29,
113,
6,
2,
1,
2,
37,
22,
0,
26,
5,
2,
1,
2,
31,
15,
0,
24,
43,
261,
18,
16,
0,
2,
12,
2,
33,
125,
0,
80,
921,
103,
110,
18,
195,
2637,
96,
16,
1071,
18,
5,
26,
3994,
6,
582,
6842,
29,
1763,
568,
8,
30,
18,
78,
18,
29,
19,
47,
17,
3,
32,
20,
6,
18,
433,
44,
212,
63,
33,
24,
3,
24,
45,
74,
6,
0,
67,
12,
65,
1,
2,
0,
15,
4,
10,
7381,
42,
31,
98,
114,
8702,
3,
2,
6,
2,
1,
2,
290,
16,
0,
30,
2,
3,
0,
15,
3,
9,
395,
2309,
106,
6,
12,
4,
8,
8,
9,
5991,
84,
2,
70,
2,
1,
3,
0,
3,
1,
3,
3,
2,
11,
2,
0,
2,
6,
2,
64,
2,
3,
3,
7,
2,
6,
2,
27,
2,
3,
2,
4,
2,
0,
4,
6,
2,
339,
3,
24,
2,
24,
2,
30,
2,
24,
2,
30,
2,
24,
2,
30,
2,
24,
2,
30,
2,
24,
2,
7,
1845,
30,
7,
5,
262,
61,
147,
44,
11,
6,
17,
0,
322,
29,
19,
43,
485,
27,
229,
29,
3,
0,
208,
30,
2,
2,
2,
1,
2,
6,
3,
4,
10,
1,
225,
6,
2,
3,
2,
1,
2,
14,
2,
196,
60,
67,
8,
0,
1205,
3,
2,
26,
2,
1,
2,
0,
3,
0,
2,
9,
2,
3,
2,
0,
2,
0,
7,
0,
5,
0,
2,
0,
2,
0,
2,
2,
2,
1,
2,
0,
3,
0,
2,
0,
2,
0,
2,
0,
2,
0,
2,
1,
2,
0,
3,
3,
2,
6,
2,
3,
2,
3,
2,
0,
2,
9,
2,
16,
6,
2,
2,
4,
2,
16,
4421,
42719,
33,
4381,
3,
5773,
3,
7472,
16,
621,
2467,
541,
1507,
4938,
6,
8489
];
const supplementaryIdentifierCodes = [
509,
0,
227,
0,
150,
4,
294,
9,
1368,
2,
2,
1,
6,
3,
41,
2,
5,
0,
166,
1,
574,
3,
9,
9,
7,
9,
32,
4,
318,
1,
78,
5,
71,
10,
50,
3,
123,
2,
54,
14,
32,
10,
3,
1,
11,
3,
46,
10,
8,
0,
46,
9,
7,
2,
37,
13,
2,
9,
6,
1,
45,
0,
13,
2,
49,
13,
9,
3,
2,
11,
83,
11,
7,
0,
3,
0,
158,
11,
6,
9,
7,
3,
56,
1,
2,
6,
3,
1,
3,
2,
10,
0,
11,
1,
3,
6,
4,
4,
68,
8,
2,
0,
3,
0,
2,
3,
2,
4,
2,
0,
15,
1,
83,
17,
10,
9,
5,
0,
82,
19,
13,
9,
214,
6,
3,
8,
28,
1,
83,
16,
16,
9,
82,
12,
9,
9,
7,
19,
58,
14,
5,
9,
243,
14,
166,
9,
71,
5,
2,
1,
3,
3,
2,
0,
2,
1,
13,
9,
120,
6,
3,
6,
4,
0,
29,
9,
41,
6,
2,
3,
9,
0,
10,
10,
47,
15,
199,
7,
137,
9,
54,
7,
2,
7,
17,
9,
57,
21,
2,
13,
123,
5,
4,
0,
2,
1,
2,
6,
2,
0,
9,
9,
49,
4,
2,
1,
2,
4,
9,
9,
55,
9,
266,
3,
10,
1,
2,
0,
49,
6,
4,
4,
14,
10,
5350,
0,
7,
14,
11465,
27,
2343,
9,
87,
9,
39,
4,
60,
6,
26,
9,
535,
9,
470,
0,
2,
54,
8,
3,
82,
0,
12,
1,
19628,
1,
4178,
9,
519,
45,
3,
22,
543,
4,
4,
5,
9,
7,
3,
6,
31,
3,
149,
2,
1418,
49,
513,
54,
5,
49,
9,
0,
15,
0,
23,
4,
2,
14,
1361,
6,
2,
16,
3,
6,
2,
1,
2,
4,
101,
0,
161,
6,
10,
9,
357,
0,
62,
13,
499,
13,
245,
1,
2,
9,
233,
0,
3,
0,
8,
1,
6,
0,
475,
6,
110,
6,
6,
9,
4759,
9,
787719,
239
];
const bmpIdentifierStart = new RegExp("[" + bmpIdentifierStartChars + "]");
const bmpIdentifier = new RegExp("[" + bmpIdentifierStartChars + bmpIdentifierChars + "]");
function isInSupplementarySet(code, set) {
let pos = 0x10000;
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(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 <= 0xffff) {
return code >= 0xaa && bmpIdentifierStart.test(String.fromCharCode(code));
}
return isInSupplementarySet(code, supplementaryIdentifierStartCodes);
}
function isIdentifierChar(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 <= 0xffff) {
return code >= 0xaa && bmpIdentifier.test(String.fromCharCode(code));
}
return isInSupplementarySet(code, supplementaryIdentifierStartCodes) || isInSupplementarySet(code, supplementaryIdentifierCodes);
}
function isIdentifierName(name) {
let isFirst = true;
for (let i = 0; i < name.length; i++) {
let cp = name.charCodeAt(i);
if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
const trail = name.charCodeAt(++i);
if ((trail & 0xfc00) === 0xdc00) {
cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
}
}
if (isFirst) {
isFirst = false;
if (!isIdentifierStart(cp)) {
return false;
}
} else if (!isIdentifierChar(cp)) {
return false;
}
}
return !isFirst;
}
const reservedWords = {
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 = new Set(reservedWords.keyword);
const reservedWordsStrictSet = new Set(reservedWords.strict);
new Set(reservedWords.strictBind);
function isReservedWord(word, inModule) {
return inModule && word === "await" || word === "enum";
}
function isStrictReservedWord(word, inModule) {
return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
}
function isKeyword(word) {
return keywords.has(word);
}
function isValidIdentifier(name, reserved = true) {
if (typeof name !== "string") return false;
if (reserved) {
if (isKeyword(name) || isStrictReservedWord(name, true)) {
return false;
}
}
return isIdentifierName(name);
}
var _isDigit = function isDigit(code) {
return code >= 48 && code <= 57;
};
function readStringContents(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(type, ch, input, pos)) {
out += input.slice(chunkStart, pos);
break;
}
if (ch === 92) {
out += input.slice(chunkStart, pos);
const res = readEscapedChar(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) {
{
out += input.slice(chunkStart, pos) + "\n";
++pos;
if (ch === 13 && input.charCodeAt(pos) === 10) {
++pos;
}
++curLine;
chunkStart = lineStart = pos;
}
} else {
++pos;
}
}
return {
pos,
str: out,
firstInvalidLoc,
lineStart,
curLine
};
}
function isStringEnd(type, ch, input, pos) {
{
return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
}
}
function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
const throwOnInvalid = false;
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(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
return res(code === null ? null : String.fromCharCode(code));
}
case 117:
{
let code;
({
code,
pos
} = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
return res(code === null ? null : String.fromCodePoint(code));
}
case 116:
return res("\t");
case 98:
return res("\b");
case 118:
return res("\u000b");
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:
{
return res(null);
}
default:
if (ch >= 48 && ch <= 55) {
const startPos = pos - 1;
const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
let octalStr = match[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) {
{
return res(null);
}
}
return res(String.fromCharCode(octal));
}
return res(String.fromCharCode(ch));
}
}
function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
const initialPos = pos;
let n;
({
n,
pos
} = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, true));
if (n === null) {
{
pos = initialPos - 1;
}
}
return {
code: n,
pos
};
}
function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
const start = pos;
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") {
input.charCodeAt(pos - 1);
input.charCodeAt(pos + 1);
{
return {
n: null,
pos
};
}
}
if (code >= 97) {
val = code - 97 + 10;
} else if (code >= 65) {
val = code - 65 + 10;
} else if (_isDigit(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(input, pos, lineStart, curLine, throwOnInvalid, errors) {
const ch = input.charCodeAt(pos);
let code;
if (ch === 123) {
++pos;
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
++pos;
if (code !== null && code > 0x10ffff) {
{
return {
code: null,
pos
};
}
}
} else {
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
}
return {
code,
pos
};
}
const LOGICAL_OPERATORS = ["||", "&&", "??"];
const UPDATE_OPERATORS = ["++", "--"];
const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
const STRING_UNARY_OPERATORS = ["typeof"];
const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
const ALIAS_KEYS = {};
const FLIPPED_ALIAS_KEYS = {};
const NODE_FIELDS$1 = {};
const DEPRECATED_KEYS = {};
const NODE_PARENT_VALIDATIONS = {};
function getType(val) {
if (Array.isArray(val)) {
return "array";
} else if (val === null) {
return "null";
} else {
return typeof val;
}
}
function combine(fn, ...validators) {
return Object.assign(fn, ...validators);
}
function validate$1(validate) {
return {
validate
};
}
function validateType(...typeNames) {
return validate$1(assertNodeType(...typeNames));
}
function validateOptional(validate) {
return {
validate,
optional: true
};
}
function validateDefault(validate, defaultValue) {
return {
validate,
default: defaultValue,
optional: false
};
}
function validateOptionalType(...typeNames) {
return {
validate: assertNodeType(...typeNames),
optional: true
};
}
function arrayOf(elementType) {
return chain(assertValueType("array"), assertEach(elementType));
}
function arrayOfType(...typeNames) {
return arrayOf(assertNodeType(...typeNames));
}
function validateArrayOfType(...typeNames) {
return validate$1(arrayOfType(...typeNames));
}
function assertEach(callback) {
const childValidator = validateChild;
function validator(node, key, val) {
if (!Array.isArray(val)) return;
let i = 0;
const subKey = {
toString() {
return `${key}[${i}]`;
}
};
for (; i < val.length; i++) {
const v = val[i];
callback(node, subKey, v);
childValidator(node, subKey, v);
}
}
validator.each = callback;
return validator;
}
function assertOneOf(...values) {
function validate(node, key, val) {
if (!values.includes(val)) {
throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
}
}
validate.oneOf = values;
return validate;
}
const allExpandedTypes = [];
function assertNodeType(...types) {
const expandedTypes = new Set();
allExpandedTypes.push({
types,
set: expandedTypes
});
function validate(node, key, val) {
const valType = val?.type;
if (valType != null) {
if (expandedTypes.has(valType)) {
validateChild(node, key, val);
return;
}
if (valType === "Placeholder") {
for (const type of types) {
if (is(type, val)) {
validateChild(node, key, val);
return;
}
}
}
}
throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(valType)}`);
}
validate.oneOfNodeTypes = types;
return validate;
}
function assertNodeOrValueType(...types) {
function validate(node, key, val) {
const primitiveType = getType(val);
for (const type of types) {
if (primitiveType === type || is(type, val)) {
validateChild(node, key, val);
return;
}
}
throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val?.type)}`);
}
validate.oneOfNodeOrValueTypes = types;
return validate;
}
function assertValueType(type) {
function validate(node, key, val) {
if (getType(val) === type) {
return;
}
throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
}
validate.type = type;
return validate;
}
function assertShape(shape) {
const keys = Object.keys(shape);
function validate(node, key, val) {
const errors = [];
for (const property of keys) {
try {
validateField(node, property, val[property], shape[property]);
} catch (error) {
if (error instanceof TypeError) {
errors.push(error.message);
continue;
}
throw error;
}
}
if (errors.length) {
throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
}
}
validate.shapeOf = shape;
return validate;
}
function assertOptionalChainStart() {
function validate(node) {
let current = node;
while (node) {
const {
type
} = current;
if (type === "OptionalCallExpression") {
if (current.optional) return;
current = current.callee;
continue;
}
if (type === "OptionalMemberExpression") {
if (current.optional) return;
current = current.object;
continue;
}
break;
}
throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${current?.type}`);
}
return validate;
}
function chain(...fns) {
function validate(...args) {
for (const fn of fns) {
fn(...args);
}
}
validate.chainOf = fns;
if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
}
return validate;
}
const validTypeOpts = new Set(["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate", "unionShape"]);
const validFieldKeys = new Set(["default", "optional", "deprecated", "validate"]);
const store = {};
function defineAliasedType(...aliases) {
return (type, opts = {}) => {
let defined = opts.aliases;
if (!defined) {
if (opts.inherits) defined = store[opts.inherits].aliases?.slice();
defined ??= [];
opts.aliases = defined;
}
const additional = aliases.filter(a => !defined.includes(a));
defined.unshift(...additional);
defineType$5(type, opts);
};
}
function defineType$5(type, opts = {}) {
const inherits = opts.inherits && store[opts.inherits] || {};
const visitor = opts.visitor || inherits.visitor || [];
const aliases = opts.aliases || inherits.aliases || [];
const builder = opts.builder || inherits.builder || opts.visitor || [];
let fields = opts.fields;
if (!fields) {
fields = {};
if (inherits.fields) {
const keys = Object.getOwnPropertyNames(inherits.fields);
for (const key of keys) {
const field = inherits.fields[key];
const def = field.default;
if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
throw new Error("field defaults can only be primitives or empty arrays currently");
}
fields[key] = {
default: Array.isArray(def) ? [] : def,
optional: field.optional,
deprecated: field.deprecated,
validate: field.validate
};
}
}
}
for (const k of Object.keys(opts)) {
if (!validTypeOpts.has(k)) {
throw new Error(`Unknown type option "${k}" on ${type}`);
}
}
if (opts.deprecatedAlias) {
DEPRECATED_KEYS[opts.deprecatedAlias] = type;
}
for (const key of visitor.concat(builder)) {
fields[key] = fields[key] || {};
}
for (const key of Object.keys(fields)) {
const field = fields[key];
if (field.default === null) {
field.optional ??= true;
}
if (field.default === undefined) {
field.default = null;
field.optional ??= false;
} else if (!field.validate && field.default != null) {
field.validate = assertValueType(getType(field.default));
}
for (const k of Object.keys(field)) {
if (!validFieldKeys.has(k)) {
throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
}
}
}
opts.visitor = visitor;
opts.builder = builder;
NODE_FIELDS$1[type] = opts.fields = fields;
ALIAS_KEYS[type] = opts.aliases = aliases;
aliases.forEach(alias => {
FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
FLIPPED_ALIAS_KEYS[alias].push(type);
});
if (opts.validate) {
NODE_PARENT_VALIDATIONS[type] = opts.validate;
}
if (opts.unionShape) {
opts.unionShape;
}
store[type] = opts;
}
const utils = /*#__PURE__*/Object.defineProperty({
__proto__: null,
ALIAS_KEYS,
DEPRECATED_KEYS,
FLIPPED_ALIAS_KEYS,
NODE_FIELDS: NODE_FIELDS$1,
NODE_PARENT_VALIDATIONS,
allExpandedTypes,
arrayOf,
arrayOfType,
assertEach,
assertNodeOrValueType,
assertNodeType,
assertOneOf,
assertOptionalChainStart,
assertShape,
assertValueType,
chain,
combine,
default: defineType$5,
defineAliasedType,
validate: validate$1,
validateArrayOfType,
validateDefault,
validateOptional,
validateOptionalType,
validateType
}, Symbol.toStringTag, { value: 'Module' });
const classMethodOrPropertyUnionShapeCommon = (allowPrivateName = false) => ({
unionShape: {
discriminator: "computed",
shapes: [{
name: "computed",
value: [true],
properties: {
key: {
validate: assertNodeType("Expression")
}
}
}, {
name: "nonComputed",
value: [false],
properties: {
key: {
validate: allowPrivateName ? assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName") : assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral")
}
}
}]
}
});
const memberExpressionUnionShapeCommon = {
unionShape: {
discriminator: "computed",
shapes: [{
name: "computed",
value: [true],
properties: {
property: {
validate: assertNodeType("Expression")
}
}
}, {
name: "nonComputed",
value: [false],
properties: {
property: {
validate: assertNodeType("Identifier", "PrivateName")
}
}
}]
}
};
const defineType$4 = defineAliasedType("Standardized");
defineType$4("ArrayExpression", {
fields: {
elements: {
validate: arrayOf(assertNodeOrValueType("null", "Expression", "SpreadElement")),
default: undefined
}
},
visitor: ["elements"],
aliases: ["Expression"]
});
defineType$4("AssignmentExpression", {
fields: {
operator: {
validate: combine(function () {
const identifier = assertOneOf(...ASSIGNMENT_OPERATORS);
const pattern = assertOneOf("=");
return function (node, key, val) {
const validator = is("Pattern", node.left) ? pattern : identifier;
validator(node, key, val);
};
}(), {
oneOf: ASSIGNMENT_OPERATORS
})
},
left: {
validate: assertNodeType("Identifier", "MemberExpression", "OptionalMemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
},
right: {
validate: assertNodeType("Expression")
}
},
builder: ["operator", "left", "right"],
visitor: ["left", "right"],
aliases: ["Expression"]
});
defineType$4("BinaryExpression", {
builder: ["operator", "left", "right"],
fields: {
operator: {
validate: assertOneOf(...BINARY_OPERATORS)
},
left: {
validate: function () {
const expression = assertNodeType("Expression");
const inOp = assertNodeType("Expression", "PrivateName");
const validator = combine(function (node, key, val) {
const validator = node.operator === "in" ? inOp : expression;
validator(node, key, val);
}, {
oneOfNodeTypes: ["Expression", "PrivateName"]
});
return validator;
}()
},
right: {
validate: assertNodeType("Expression")
}
},
unionShape: {
discriminator: "operator",
shapes: [{
name: "in",
value: ["in"],
properties: {
left: {
validate: assertNodeType("Expression", "PrivateName")
}
}
}, {
name: "notIn",
value: BINARY_OPERATORS.filter(op => op !== "in"),
properties: {
left: {
validate: assertNodeType("Expression")
}
}
}]
},
visitor: ["left", "right"],
aliases: ["Binary", "Expression"]
});
defineType$4("InterpreterDirective", {
builder: ["value"],
fields: {
value: {
validate: assertValueType("string")
}
}
});
defineType$4("Directive", {
visitor: ["value"],
fields: {
value: {
validate: assertNodeType("DirectiveLiteral")
}
}
});
defineType$4("DirectiveLiteral", {
builder: ["value"],
fields: {
value: {
validate: assertValueType("string")
}
}
});
defineType$4("BlockStatement", {
builder: ["body", "directives"],
visitor: ["directives", "body"],
fields: {
directives: {
validate: arrayOfType("Directive"),
default: []
},
body: validateArrayOfType("Statement")
},
aliases: ["Scopable", "BlockParent", "Block", "Statement"]
});
defineType$4("BreakStatement", {
visitor: ["label"],
fields: {
label: {
validate: assertNodeType("Identifier"),
optional: true
}
},
aliases: ["Statement", "Terminatorless", "CompletionStatement"]
});
defineType$4("CallExpression", {
visitor: ["callee", "typeArguments", "arguments"],
builder: ["callee", "arguments"],
aliases: ["Expression"],
fields: {
callee: {
validate: assertNodeType("Expression", "Super", "Import", "V8IntrinsicIdentifier")
},
arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
typeArguments: {
validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
optional: true
}
}
});
defineType$4("CatchClause", {
visitor: ["param", "body"],
fields: {
param: {
validate: assertNodeType("Identifier", "ArrayPattern", "ObjectPattern"),
optional: true
},
body: {
validate: assertNodeType("BlockStatement")
}
},
aliases: ["Scopable", "BlockParent"]
});
defineType$4("ConditionalExpression", {
visitor: ["test", "consequent", "alternate"],
fields: {
test: {
validate: assertNodeType("Expression")
},
consequent: {
validate: assertNodeType("Expression")
},
alternate: {
validate: assertNodeType("Expression")
}
},
aliases: ["Expression", "Conditional"]
});
defineType$4("ContinueStatement", {
visitor: ["label"],
fields: {
label: {
validate: assertNodeType("Identifier"),
optional: true
}
},
aliases: ["Statement", "Terminatorless", "CompletionStatement"]
});
defineType$4("DebuggerStatement", {
aliases: ["Statement"]
});
defineType$4("DoWhileStatement", {
builder: ["test", "body"],
visitor: ["body", "test"],
fields: {
test: {
validate: assertNodeType("Expression")
},
body: {
validate: assertNodeType("Statement")
}
},
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
});
defineType$4("EmptyStatement", {
aliases: ["Statement"]
});
defineType$4("ExpressionStatement", {
visitor: ["expression"],
fields: {
expression: {
validate: assertNodeType("Expression")
}
},
aliases: ["Statement", "ExpressionWrapper"]
});
defineType$4("File", {
builder: ["program", "comments", "tokens"],
visitor: ["program"],
fields: {
program: {
validate: assertNodeType("Program")
},
comments: {
validate: assertEach(assertNodeType("CommentBlock", "CommentLine")),
optional: true
},
tokens: {
validate: assertEach(Object.assign(() => {}, {
type: "any"
})),
optional: true
}
}
});
defineType$4("ForInStatement", {
visitor: ["left", "right", "body"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
fields: {
left: {
validate: assertNodeType("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
},
right: {
validate: assertNodeType("Expression")
},
body: {
validate: assertNodeType("Statement")
}
}
});
defineType$4("ForStatement", {
visitor: ["init", "test", "update", "body"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
fields: {
init: {
validate: assertNodeType("VariableDeclaration", "Expression"),
optional: true
},
test: {
validate: assertNodeType("Expression"),
optional: true
},
update: {
validate: assertNodeType("Expression"),
optional: true
},
body: {
validate: assertNodeType("Statement")
}
}
});
const functionCommon = () => ({
params: validateArrayOfType("FunctionParameter"),
generator: {
default: false
},
async: {
default: false
}
});
const functionTypeAnnotationCommon = () => ({
returnType: {
validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
optional: true
},
typeParameters: {
validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
optional: true
}
});
const functionDeclarationCommon = () => ({
...functionCommon(),
declare: {
validate: assertValueType("boolean"),
optional: true
},
id: {
validate: assertNodeType("Identifier"),
optional: true
}
});
defineType$4("FunctionDeclaration", {
builder: ["id", "params", "body", "generator", "async"],
visitor: ["id", "typeParameters", "params", "predicate", "returnType", "body"],
fields: {
...functionDeclarationCommon(),
...functionTypeAnnotationCommon(),
body: {
validate: assertNodeType("BlockStatement")
},
predicate: {
validate: assertNodeType("FlowPredicate"),
optional: true
}
},
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
validate: function () {
const identifier = assertNodeType("Identifier");
return function (parent, key, node) {
if (!is("ExportDefaultDeclaration", parent)) {
identifier(node, "id", node.id);
}
};
}()
});
defineType$4("FunctionExpression", {
inherits: "FunctionDeclaration",
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
fields: {
...functionCommon(),
...functionTypeAnnotationCommon(),
id: {
validate: assertNodeType("Identifier"),
optional: true
},
body: {
validate: assertNodeType("BlockStatement")
},
predicate: {
validate: assertNodeType("FlowPredicate"),
optional: true
}
}
});
const patternLikeCommon = () => ({
typeAnnotation: {
validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
optional: true
},
optional: {
validate: assertValueType("boolean"),
optional: true
},
decorators: {
validate: arrayOfType("Decorator"),
optional: true
}
});
defineType$4("Identifier", {
builder: ["name"],
visitor: ["typeAnnotation", "decorators"],
aliases: ["Expression", "FunctionParameter", "PatternLike", "LVal", "TSEntityName"],
fields: {
...patternLikeCommon(),
name: {
validate: chain(assertValueType("string"), combine(function (node, key, val) {
if (!isValidIdentifier(val, false)) {
throw new TypeError(`"${val}" is not a valid identifier name`);
}
}, {
type: "string"
}))
}
},
validate: function (parent, key, node) {
const match = /\.(\w+)$/.exec(key.toString());
if (!match) return;
const [, parentKey] = match;
const nonComp = {
computed: false
};
if (parentKey === "property") {
if (is("MemberExpression", parent, nonComp)) return;
if (is("OptionalMemberExpression", parent, nonComp)) return;
} else if (parentKey === "key") {
if (is("Property", parent, nonComp)) return;
if (is("Method", parent, nonComp)) return;
} else if (parentKey === "exported") {
if (is("ExportSpecifier", parent)) return;
} else if (parentKey === "imported") {
if (is("ImportSpecifier", parent, {
imported: node
})) return;
} else if (parentKey === "meta") {
if (is("MetaProperty", parent, {
meta: node
})) return;
}
if ((isKeyword(node.name) || isReservedWord(node.name, false)) && node.name !== "this") {
throw new TypeError(`"${node.name}" is not a valid identifier`);
}
}
});
defineType$4("IfStatement", {
visitor: ["test", "consequent", "alternate"],
aliases: ["Statement", "Conditional"],
fields: {
test: {
validate: assertNodeType("Expression")
},
consequent: {
validate: assertNodeType("Statement")
},
alternate: {
optional: true,
validate: assertNodeType("Statement")
}
}
});
defineType$4("LabeledStatement", {
visitor: ["label", "body"],
aliases: ["Statement"],
fields: {
label: {
validate: assertNodeType("Identifier")
},
body: {
validate: assertNodeType("Statement")
}
}
});
defineType$4("StringLiteral", {
builder: ["value"],
fields: {
value: {
validate: assertValueType("string")
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType$4("NumericLiteral", {
builder: ["value"],
deprecatedAlias: "NumberLiteral",
fields: {
value: {
validate: chain(assertValueType("number"), combine(function (node, key, val) {
if (1 / val < 0 || !Number.isFinite(val)) {
const error = new Error("NumericLiterals must be non-negative finite numbers. " + `You can use t.valueToNode(${val}) instead.`);
if (!new Error().stack.includes("regenerator")) {
throw error;
}
}
}, {
type: "number"
}))
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType$4("NullLiteral", {
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType$4("BooleanLiteral", {
builder: ["value"],
fields: {
value: {
validate: assertValueType("boolean")
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType$4("RegExpLiteral", {
builder: ["pattern", "flags"],
deprecatedAlias: "RegexLiteral",
aliases: ["Expression", "Pureish", "Literal"],
fields: {
pattern: {
validate: assertValueType("string")
},
flags: {
validate: chain(assertValueType("string"), combine(function (node, key, val) {
const invalid = /[^dgimsuvy]/.exec(val);
if (invalid) {
throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
}
}, {
type: "string"
})),
default: ""
}
}
});
defineType$4("LogicalExpression", {
builder: ["operator", "left", "right"],
visitor: ["left", "right"],
aliases: ["Binary", "Expression"],
fields: {
operator: {
validate: assertOneOf(...LOGICAL_OPERATORS)
},
left: {
validate: assertNodeType("Expression")
},
right: {
validate: assertNodeType("Expression")
}
}
});
defineType$4("MemberExpression", {
builder: ["object", "property", "computed"],
visitor: ["object", "property"],
aliases: ["Expression", "LVal", "PatternLike"],
...memberExpressionUnionShapeCommon,
fields: {
object: {
validate: assertNodeType("Expression", "Super")
},
property: {
validate: function () {
const normal = assertNodeType("Identifier", "PrivateName");
const computed = assertNodeType("Expression");
const validator = combine(function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
}, {
oneOfNodeTypes: ["Expression", "Identifier", "PrivateName"]
});
return validator;
}()
},
computed: {
default: false
}
}
});
defineType$4("NewExpression", {
inherits: "CallExpression",
fields: {
callee: {
validate: assertNodeType("Expression")
},
argumen