prettier-plugin-ember-template-tag
Version:
A prettier plugin for formatting Ember template tags
1,290 lines • 1.54 MB
JavaScript
"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const babel = require("prettier/plugins/babel");
const contentTag = require("content-tag");
const estree = require("prettier/plugins/estree");
const prettier = require("prettier");
const PARSER_NAME = "ember-template-tag";
const PRINTER_NAME = "ember-template-tag-estree";
const TEMPLATE_TAG_OPEN = "<template>";
const TEMPLATE_TAG_CLOSE = "</template>";
const languages = [
{
aliases: ["gjs", "glimmer-js"],
extensions: [".gjs"],
group: "JavaScript",
name: "Ember Template Tag (gjs)",
parsers: [PARSER_NAME],
vscodeLanguageIds: ["glimmer-js"]
},
{
aliases: ["gts", "glimmer-ts"],
extensions: [".gts"],
group: "TypeScript",
name: "Ember Template Tag (gts)",
parsers: [PARSER_NAME],
vscodeLanguageIds: ["glimmer-ts"]
}
];
const templateExportDefault = {
category: "Format",
default: false,
description: 'Prepend default export template tags with "export default". Since 0.1.0.',
type: "boolean"
};
const templateSingleQuote = {
category: "Format",
description: "Use single quotes instead of double quotes within template tags. Since 0.0.3.",
type: "boolean"
};
const options$1 = {
templateExportDefault,
templateSingleQuote
};
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var lib$7 = {};
var context$1 = {};
var traverseNode = {};
var context = {};
var path = {};
var virtualTypes = {};
var hasRequiredVirtualTypes;
function requireVirtualTypes() {
if (hasRequiredVirtualTypes) return virtualTypes;
hasRequiredVirtualTypes = 1;
Object.defineProperty(virtualTypes, "__esModule", {
value: true
});
virtualTypes.Var = virtualTypes.User = virtualTypes.Statement = virtualTypes.SpreadProperty = virtualTypes.Scope = virtualTypes.RestProperty = virtualTypes.ReferencedMemberExpression = virtualTypes.ReferencedIdentifier = virtualTypes.Referenced = virtualTypes.Pure = virtualTypes.NumericLiteralTypeAnnotation = virtualTypes.Generated = virtualTypes.ForAwaitStatement = virtualTypes.Flow = virtualTypes.Expression = virtualTypes.ExistentialTypeParam = virtualTypes.BlockScoped = virtualTypes.BindingIdentifier = void 0;
virtualTypes.ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
virtualTypes.ReferencedMemberExpression = ["MemberExpression"];
virtualTypes.BindingIdentifier = ["Identifier"];
virtualTypes.Statement = ["Statement"];
virtualTypes.Expression = ["Expression"];
virtualTypes.Scope = ["Scopable", "Pattern"];
virtualTypes.Referenced = null;
virtualTypes.BlockScoped = ["FunctionDeclaration", "ClassDeclaration", "VariableDeclaration"];
virtualTypes.Var = ["VariableDeclaration"];
virtualTypes.User = null;
virtualTypes.Generated = null;
virtualTypes.Pure = null;
virtualTypes.Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
virtualTypes.RestProperty = ["RestElement"];
virtualTypes.SpreadProperty = ["RestElement"];
virtualTypes.ExistentialTypeParam = ["ExistsTypeAnnotation"];
virtualTypes.NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"];
virtualTypes.ForAwaitStatement = ["ForOfStatement"];
return virtualTypes;
}
var browser = { exports: {} };
var ms;
var hasRequiredMs;
function requireMs() {
if (hasRequiredMs) return ms;
hasRequiredMs = 1;
var s = 1e3;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var w = d * 7;
var y = d * 365.25;
ms = function(val, options2) {
options2 = options2 || {};
var type = typeof val;
if (type === "string" && val.length > 0) {
return parse2(val);
} else if (type === "number" && isFinite(val)) {
return options2.long ? fmtLong(val) : fmtShort(val);
}
throw new Error(
"val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
);
};
function parse2(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
str
);
if (!match) {
return;
}
var n = parseFloat(match[1]);
var type = (match[2] || "ms").toLowerCase();
switch (type) {
case "years":
case "year":
case "yrs":
case "yr":
case "y":
return n * y;
case "weeks":
case "week":
case "w":
return n * w;
case "days":
case "day":
case "d":
return n * d;
case "hours":
case "hour":
case "hrs":
case "hr":
case "h":
return n * h;
case "minutes":
case "minute":
case "mins":
case "min":
case "m":
return n * m;
case "seconds":
case "second":
case "secs":
case "sec":
case "s":
return n * s;
case "milliseconds":
case "millisecond":
case "msecs":
case "msec":
case "ms":
return n;
default:
return void 0;
}
}
function fmtShort(ms2) {
var msAbs = Math.abs(ms2);
if (msAbs >= d) {
return Math.round(ms2 / d) + "d";
}
if (msAbs >= h) {
return Math.round(ms2 / h) + "h";
}
if (msAbs >= m) {
return Math.round(ms2 / m) + "m";
}
if (msAbs >= s) {
return Math.round(ms2 / s) + "s";
}
return ms2 + "ms";
}
function fmtLong(ms2) {
var msAbs = Math.abs(ms2);
if (msAbs >= d) {
return plural(ms2, msAbs, d, "day");
}
if (msAbs >= h) {
return plural(ms2, msAbs, h, "hour");
}
if (msAbs >= m) {
return plural(ms2, msAbs, m, "minute");
}
if (msAbs >= s) {
return plural(ms2, msAbs, s, "second");
}
return ms2 + " ms";
}
function plural(ms2, msAbs, n, name) {
var isPlural = msAbs >= n * 1.5;
return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
}
return ms;
}
var common;
var hasRequiredCommon;
function requireCommon() {
if (hasRequiredCommon) return common;
hasRequiredCommon = 1;
function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = requireMs();
createDebug.destroy = destroy;
Object.keys(env).forEach((key) => {
createDebug[key] = env[key];
});
createDebug.names = [];
createDebug.skips = [];
createDebug.formatters = {};
function selectColor(namespace) {
let hash = 0;
for (let i = 0; i < namespace.length; i++) {
hash = (hash << 5) - hash + namespace.charCodeAt(i);
hash |= 0;
}
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
}
createDebug.selectColor = selectColor;
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;
function debug(...args) {
if (!debug.enabled) {
return;
}
const self2 = debug;
const curr = Number(/* @__PURE__ */ new Date());
const ms2 = curr - (prevTime || curr);
self2.diff = ms2;
self2.prev = prevTime;
self2.curr = curr;
prevTime = curr;
args[0] = createDebug.coerce(args[0]);
if (typeof args[0] !== "string") {
args.unshift("%O");
}
let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
if (match === "%%") {
return "%";
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === "function") {
const val = args[index];
match = formatter.call(self2, val);
args.splice(index, 1);
index--;
}
return match;
});
createDebug.formatArgs.call(self2, args);
const logFn = self2.log || createDebug.log;
logFn.apply(self2, args);
}
debug.namespace = namespace;
debug.useColors = createDebug.useColors();
debug.color = createDebug.selectColor(namespace);
debug.extend = extend;
debug.destroy = createDebug.destroy;
Object.defineProperty(debug, "enabled", {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}
return enabledCache;
},
set: (v) => {
enableOverride = v;
}
});
if (typeof createDebug.init === "function") {
createDebug.init(debug);
}
return debug;
}
function extend(namespace, delimiter) {
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;
createDebug.names = [];
createDebug.skips = [];
const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
for (const ns of split) {
if (ns[0] === "-") {
createDebug.skips.push(ns.slice(1));
} else {
createDebug.names.push(ns);
}
}
}
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 disable() {
const namespaces = [
...createDebug.names,
...createDebug.skips.map((namespace) => "-" + namespace)
].join(",");
createDebug.enable("");
return namespaces;
}
function enabled(name) {
for (const skip of createDebug.skips) {
if (matchesTemplate(name, skip)) {
return false;
}
}
for (const ns of createDebug.names) {
if (matchesTemplate(name, ns)) {
return true;
}
}
return false;
}
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}
function destroy() {
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
createDebug.enable(createDebug.load());
return createDebug;
}
common = setup;
return common;
}
var hasRequiredBrowser;
function requireBrowser() {
if (hasRequiredBrowser) return browser.exports;
hasRequiredBrowser = 1;
(function(module2, exports$1) {
exports$1.formatArgs = formatArgs;
exports$1.save = save;
exports$1.load = load;
exports$1.useColors = useColors;
exports$1.storage = localstorage();
exports$1.destroy = /* @__PURE__ */ (() => {
let warned = false;
return () => {
if (!warned) {
warned = true;
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
};
})();
exports$1.colors = [
"#0000CC",
"#0000FF",
"#0033CC",
"#0033FF",
"#0066CC",
"#0066FF",
"#0099CC",
"#0099FF",
"#00CC00",
"#00CC33",
"#00CC66",
"#00CC99",
"#00CCCC",
"#00CCFF",
"#3300CC",
"#3300FF",
"#3333CC",
"#3333FF",
"#3366CC",
"#3366FF",
"#3399CC",
"#3399FF",
"#33CC00",
"#33CC33",
"#33CC66",
"#33CC99",
"#33CCCC",
"#33CCFF",
"#6600CC",
"#6600FF",
"#6633CC",
"#6633FF",
"#66CC00",
"#66CC33",
"#9900CC",
"#9900FF",
"#9933CC",
"#9933FF",
"#99CC00",
"#99CC33",
"#CC0000",
"#CC0033",
"#CC0066",
"#CC0099",
"#CC00CC",
"#CC00FF",
"#CC3300",
"#CC3333",
"#CC3366",
"#CC3399",
"#CC33CC",
"#CC33FF",
"#CC6600",
"#CC6633",
"#CC9900",
"#CC9933",
"#CCCC00",
"#CCCC33",
"#FF0000",
"#FF0033",
"#FF0066",
"#FF0099",
"#FF00CC",
"#FF00FF",
"#FF3300",
"#FF3333",
"#FF3366",
"#FF3399",
"#FF33CC",
"#FF33FF",
"#FF6600",
"#FF6633",
"#FF9900",
"#FF9933",
"#FFCC00",
"#FFCC33"
];
function useColors() {
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
return true;
}
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
return false;
}
let m;
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}
function formatArgs(args) {
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
if (!this.useColors) {
return;
}
const c = "color: " + this.color;
args.splice(1, 0, c, "color: inherit");
let index = 0;
let lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, (match) => {
if (match === "%%") {
return;
}
index++;
if (match === "%c") {
lastC = index;
}
});
args.splice(lastC, 0, c);
}
exports$1.log = console.debug || console.log || (() => {
});
function save(namespaces) {
try {
if (namespaces) {
exports$1.storage.setItem("debug", namespaces);
} else {
exports$1.storage.removeItem("debug");
}
} catch (error) {
}
}
function load() {
let r;
try {
r = exports$1.storage.getItem("debug") || exports$1.storage.getItem("DEBUG");
} catch (error) {
}
if (!r && typeof process !== "undefined" && "env" in process) {
r = process.env.DEBUG;
}
return r;
}
function localstorage() {
try {
return localStorage;
} catch (error) {
}
}
module2.exports = requireCommon()(exports$1);
const { formatters: formatters2 } = module2.exports;
formatters2.j = function(v) {
try {
return JSON.stringify(v);
} catch (error) {
return "[UnexpectedJSONParseError]: " + error.message;
}
};
})(browser, browser.exports);
return browser.exports;
}
var scope = {};
var renamer = {};
var lib$6 = {};
var isReactComponent = {};
var buildMatchMemberExpression = {};
var matchesPattern = {};
var generated$3 = {};
var shallowEqual = {};
var hasRequiredShallowEqual;
function requireShallowEqual() {
if (hasRequiredShallowEqual) return shallowEqual;
hasRequiredShallowEqual = 1;
Object.defineProperty(shallowEqual, "__esModule", {
value: true
});
shallowEqual.default = shallowEqual$1;
function shallowEqual$1(actual, expected) {
const keys = Object.keys(expected);
for (const key of keys) {
if (actual[key] !== expected[key]) {
return false;
}
}
return true;
}
return shallowEqual;
}
var deprecationWarning = {};
var hasRequiredDeprecationWarning;
function requireDeprecationWarning() {
if (hasRequiredDeprecationWarning) return deprecationWarning;
hasRequiredDeprecationWarning = 1;
Object.defineProperty(deprecationWarning, "__esModule", {
value: true
});
deprecationWarning.default = deprecationWarning$1;
const warnings = /* @__PURE__ */ new Set();
function deprecationWarning$1(oldName, newName, prefix = "", cacheKey = oldName) {
if (warnings.has(cacheKey)) return;
warnings.add(cacheKey);
const {
internal,
trace
} = captureShortStackTrace(1, 2);
if (internal) {
return;
}
console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`
${trace}`);
}
function captureShortStackTrace(skip, length) {
const {
stackTraceLimit,
prepareStackTrace
} = Error;
let stackTrace;
Error.stackTraceLimit = 1 + skip + length;
Error.prepareStackTrace = function(err, stack) {
stackTrace = stack;
};
new Error().stack;
Error.stackTraceLimit = stackTraceLimit;
Error.prepareStackTrace = prepareStackTrace;
if (!stackTrace) return {
internal: false,
trace: ""
};
const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);
return {
internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()),
trace: shortStackTrace.map((frame) => ` at ${frame}`).join("\n")
};
}
return deprecationWarning;
}
var hasRequiredGenerated$3;
function requireGenerated$3() {
if (hasRequiredGenerated$3) return generated$3;
hasRequiredGenerated$3 = 1;
Object.defineProperty(generated$3, "__esModule", {
value: true
});
generated$3.isAccessor = isAccessor;
generated$3.isAnyTypeAnnotation = isAnyTypeAnnotation;
generated$3.isArgumentPlaceholder = isArgumentPlaceholder;
generated$3.isArrayExpression = isArrayExpression;
generated$3.isArrayPattern = isArrayPattern;
generated$3.isArrayTypeAnnotation = isArrayTypeAnnotation;
generated$3.isArrowFunctionExpression = isArrowFunctionExpression;
generated$3.isAssignmentExpression = isAssignmentExpression;
generated$3.isAssignmentPattern = isAssignmentPattern;
generated$3.isAwaitExpression = isAwaitExpression;
generated$3.isBigIntLiteral = isBigIntLiteral;
generated$3.isBinary = isBinary;
generated$3.isBinaryExpression = isBinaryExpression;
generated$3.isBindExpression = isBindExpression;
generated$3.isBlock = isBlock;
generated$3.isBlockParent = isBlockParent;
generated$3.isBlockStatement = isBlockStatement;
generated$3.isBooleanLiteral = isBooleanLiteral;
generated$3.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
generated$3.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
generated$3.isBreakStatement = isBreakStatement;
generated$3.isCallExpression = isCallExpression;
generated$3.isCatchClause = isCatchClause;
generated$3.isClass = isClass;
generated$3.isClassAccessorProperty = isClassAccessorProperty;
generated$3.isClassBody = isClassBody;
generated$3.isClassDeclaration = isClassDeclaration;
generated$3.isClassExpression = isClassExpression;
generated$3.isClassImplements = isClassImplements;
generated$3.isClassMethod = isClassMethod;
generated$3.isClassPrivateMethod = isClassPrivateMethod;
generated$3.isClassPrivateProperty = isClassPrivateProperty;
generated$3.isClassProperty = isClassProperty;
generated$3.isCompletionStatement = isCompletionStatement;
generated$3.isConditional = isConditional;
generated$3.isConditionalExpression = isConditionalExpression;
generated$3.isContinueStatement = isContinueStatement;
generated$3.isDebuggerStatement = isDebuggerStatement;
generated$3.isDecimalLiteral = isDecimalLiteral;
generated$3.isDeclaration = isDeclaration;
generated$3.isDeclareClass = isDeclareClass;
generated$3.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
generated$3.isDeclareExportDeclaration = isDeclareExportDeclaration;
generated$3.isDeclareFunction = isDeclareFunction;
generated$3.isDeclareInterface = isDeclareInterface;
generated$3.isDeclareModule = isDeclareModule;
generated$3.isDeclareModuleExports = isDeclareModuleExports;
generated$3.isDeclareOpaqueType = isDeclareOpaqueType;
generated$3.isDeclareTypeAlias = isDeclareTypeAlias;
generated$3.isDeclareVariable = isDeclareVariable;
generated$3.isDeclaredPredicate = isDeclaredPredicate;
generated$3.isDecorator = isDecorator;
generated$3.isDirective = isDirective;
generated$3.isDirectiveLiteral = isDirectiveLiteral;
generated$3.isDoExpression = isDoExpression;
generated$3.isDoWhileStatement = isDoWhileStatement;
generated$3.isEmptyStatement = isEmptyStatement;
generated$3.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
generated$3.isEnumBody = isEnumBody;
generated$3.isEnumBooleanBody = isEnumBooleanBody;
generated$3.isEnumBooleanMember = isEnumBooleanMember;
generated$3.isEnumDeclaration = isEnumDeclaration;
generated$3.isEnumDefaultedMember = isEnumDefaultedMember;
generated$3.isEnumMember = isEnumMember;
generated$3.isEnumNumberBody = isEnumNumberBody;
generated$3.isEnumNumberMember = isEnumNumberMember;
generated$3.isEnumStringBody = isEnumStringBody;
generated$3.isEnumStringMember = isEnumStringMember;
generated$3.isEnumSymbolBody = isEnumSymbolBody;
generated$3.isExistsTypeAnnotation = isExistsTypeAnnotation;
generated$3.isExportAllDeclaration = isExportAllDeclaration;
generated$3.isExportDeclaration = isExportDeclaration;
generated$3.isExportDefaultDeclaration = isExportDefaultDeclaration;
generated$3.isExportDefaultSpecifier = isExportDefaultSpecifier;
generated$3.isExportNamedDeclaration = isExportNamedDeclaration;
generated$3.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
generated$3.isExportSpecifier = isExportSpecifier;
generated$3.isExpression = isExpression;
generated$3.isExpressionStatement = isExpressionStatement;
generated$3.isExpressionWrapper = isExpressionWrapper;
generated$3.isFile = isFile;
generated$3.isFlow = isFlow;
generated$3.isFlowBaseAnnotation = isFlowBaseAnnotation;
generated$3.isFlowDeclaration = isFlowDeclaration;
generated$3.isFlowPredicate = isFlowPredicate;
generated$3.isFlowType = isFlowType;
generated$3.isFor = isFor;
generated$3.isForInStatement = isForInStatement;
generated$3.isForOfStatement = isForOfStatement;
generated$3.isForStatement = isForStatement;
generated$3.isForXStatement = isForXStatement;
generated$3.isFunction = isFunction;
generated$3.isFunctionDeclaration = isFunctionDeclaration;
generated$3.isFunctionExpression = isFunctionExpression;
generated$3.isFunctionParameter = isFunctionParameter;
generated$3.isFunctionParent = isFunctionParent;
generated$3.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
generated$3.isFunctionTypeParam = isFunctionTypeParam;
generated$3.isGenericTypeAnnotation = isGenericTypeAnnotation;
generated$3.isIdentifier = isIdentifier;
generated$3.isIfStatement = isIfStatement;
generated$3.isImmutable = isImmutable2;
generated$3.isImport = isImport;
generated$3.isImportAttribute = isImportAttribute;
generated$3.isImportDeclaration = isImportDeclaration;
generated$3.isImportDefaultSpecifier = isImportDefaultSpecifier;
generated$3.isImportExpression = isImportExpression;
generated$3.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
generated$3.isImportOrExportDeclaration = isImportOrExportDeclaration;
generated$3.isImportSpecifier = isImportSpecifier;
generated$3.isIndexedAccessType = isIndexedAccessType;
generated$3.isInferredPredicate = isInferredPredicate;
generated$3.isInterfaceDeclaration = isInterfaceDeclaration;
generated$3.isInterfaceExtends = isInterfaceExtends;
generated$3.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
generated$3.isInterpreterDirective = isInterpreterDirective;
generated$3.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
generated$3.isJSX = isJSX;
generated$3.isJSXAttribute = isJSXAttribute;
generated$3.isJSXClosingElement = isJSXClosingElement;
generated$3.isJSXClosingFragment = isJSXClosingFragment;
generated$3.isJSXElement = isJSXElement;
generated$3.isJSXEmptyExpression = isJSXEmptyExpression;
generated$3.isJSXExpressionContainer = isJSXExpressionContainer;
generated$3.isJSXFragment = isJSXFragment;
generated$3.isJSXIdentifier = isJSXIdentifier;
generated$3.isJSXMemberExpression = isJSXMemberExpression;
generated$3.isJSXNamespacedName = isJSXNamespacedName;
generated$3.isJSXOpeningElement = isJSXOpeningElement;
generated$3.isJSXOpeningFragment = isJSXOpeningFragment;
generated$3.isJSXSpreadAttribute = isJSXSpreadAttribute;
generated$3.isJSXSpreadChild = isJSXSpreadChild;
generated$3.isJSXText = isJSXText;
generated$3.isLVal = isLVal;
generated$3.isLabeledStatement = isLabeledStatement;
generated$3.isLiteral = isLiteral;
generated$3.isLogicalExpression = isLogicalExpression;
generated$3.isLoop = isLoop;
generated$3.isMemberExpression = isMemberExpression;
generated$3.isMetaProperty = isMetaProperty;
generated$3.isMethod = isMethod;
generated$3.isMiscellaneous = isMiscellaneous;
generated$3.isMixedTypeAnnotation = isMixedTypeAnnotation;
generated$3.isModuleDeclaration = isModuleDeclaration;
generated$3.isModuleExpression = isModuleExpression;
generated$3.isModuleSpecifier = isModuleSpecifier;
generated$3.isNewExpression = isNewExpression;
generated$3.isNoop = isNoop;
generated$3.isNullLiteral = isNullLiteral;
generated$3.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
generated$3.isNullableTypeAnnotation = isNullableTypeAnnotation;
generated$3.isNumberLiteral = isNumberLiteral;
generated$3.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
generated$3.isNumberTypeAnnotation = isNumberTypeAnnotation;
generated$3.isNumericLiteral = isNumericLiteral;
generated$3.isObjectExpression = isObjectExpression;
generated$3.isObjectMember = isObjectMember;
generated$3.isObjectMethod = isObjectMethod;
generated$3.isObjectPattern = isObjectPattern;
generated$3.isObjectProperty = isObjectProperty;
generated$3.isObjectTypeAnnotation = isObjectTypeAnnotation;
generated$3.isObjectTypeCallProperty = isObjectTypeCallProperty;
generated$3.isObjectTypeIndexer = isObjectTypeIndexer;
generated$3.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
generated$3.isObjectTypeProperty = isObjectTypeProperty;
generated$3.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
generated$3.isOpaqueType = isOpaqueType;
generated$3.isOptionalCallExpression = isOptionalCallExpression;
generated$3.isOptionalIndexedAccessType = isOptionalIndexedAccessType;
generated$3.isOptionalMemberExpression = isOptionalMemberExpression;
generated$3.isParenthesizedExpression = isParenthesizedExpression;
generated$3.isPattern = isPattern;
generated$3.isPatternLike = isPatternLike;
generated$3.isPipelineBareFunction = isPipelineBareFunction;
generated$3.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
generated$3.isPipelineTopicExpression = isPipelineTopicExpression;
generated$3.isPlaceholder = isPlaceholder;
generated$3.isPrivate = isPrivate;
generated$3.isPrivateName = isPrivateName;
generated$3.isProgram = isProgram;
generated$3.isProperty = isProperty;
generated$3.isPureish = isPureish;
generated$3.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
generated$3.isRecordExpression = isRecordExpression;
generated$3.isRegExpLiteral = isRegExpLiteral;
generated$3.isRegexLiteral = isRegexLiteral;
generated$3.isRestElement = isRestElement;
generated$3.isRestProperty = isRestProperty;
generated$3.isReturnStatement = isReturnStatement;
generated$3.isScopable = isScopable;
generated$3.isSequenceExpression = isSequenceExpression;
generated$3.isSpreadElement = isSpreadElement;
generated$3.isSpreadProperty = isSpreadProperty;
generated$3.isStandardized = isStandardized;
generated$3.isStatement = isStatement;
generated$3.isStaticBlock = isStaticBlock;
generated$3.isStringLiteral = isStringLiteral;
generated$3.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
generated$3.isStringTypeAnnotation = isStringTypeAnnotation;
generated$3.isSuper = isSuper;
generated$3.isSwitchCase = isSwitchCase;
generated$3.isSwitchStatement = isSwitchStatement;
generated$3.isSymbolTypeAnnotation = isSymbolTypeAnnotation;
generated$3.isTSAnyKeyword = isTSAnyKeyword;
generated$3.isTSArrayType = isTSArrayType;
generated$3.isTSAsExpression = isTSAsExpression;
generated$3.isTSBaseType = isTSBaseType;
generated$3.isTSBigIntKeyword = isTSBigIntKeyword;
generated$3.isTSBooleanKeyword = isTSBooleanKeyword;
generated$3.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
generated$3.isTSConditionalType = isTSConditionalType;
generated$3.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
generated$3.isTSConstructorType = isTSConstructorType;
generated$3.isTSDeclareFunction = isTSDeclareFunction;
generated$3.isTSDeclareMethod = isTSDeclareMethod;
generated$3.isTSEntityName = isTSEntityName;
generated$3.isTSEnumBody = isTSEnumBody;
generated$3.isTSEnumDeclaration = isTSEnumDeclaration;
generated$3.isTSEnumMember = isTSEnumMember;
generated$3.isTSExportAssignment = isTSExportAssignment;
generated$3.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
generated$3.isTSExternalModuleReference = isTSExternalModuleReference;
generated$3.isTSFunctionType = isTSFunctionType;
generated$3.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
generated$3.isTSImportType = isTSImportType;
generated$3.isTSIndexSignature = isTSIndexSignature;
generated$3.isTSIndexedAccessType = isTSIndexedAccessType;
generated$3.isTSInferType = isTSInferType;
generated$3.isTSInstantiationExpression = isTSInstantiationExpression;
generated$3.isTSInterfaceBody = isTSInterfaceBody;
generated$3.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
generated$3.isTSIntersectionType = isTSIntersectionType;
generated$3.isTSIntrinsicKeyword = isTSIntrinsicKeyword;
generated$3.isTSLiteralType = isTSLiteralType;
generated$3.isTSMappedType = isTSMappedType;
generated$3.isTSMethodSignature = isTSMethodSignature;
generated$3.isTSModuleBlock = isTSModuleBlock;
generated$3.isTSModuleDeclaration = isTSModuleDeclaration;
generated$3.isTSNamedTupleMember = isTSNamedTupleMember;
generated$3.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
generated$3.isTSNeverKeyword = isTSNeverKeyword;
generated$3.isTSNonNullExpression = isTSNonNullExpression;
generated$3.isTSNullKeyword = isTSNullKeyword;
generated$3.isTSNumberKeyword = isTSNumberKeyword;
generated$3.isTSObjectKeyword = isTSObjectKeyword;
generated$3.isTSOptionalType = isTSOptionalType;
generated$3.isTSParameterProperty = isTSParameterProperty;
generated$3.isTSParenthesizedType = isTSParenthesizedType;
generated$3.isTSPropertySignature = isTSPropertySignature;
generated$3.isTSQualifiedName = isTSQualifiedName;
generated$3.isTSRestType = isTSRestType;
generated$3.isTSSatisfiesExpression = isTSSatisfiesExpression;
generated$3.isTSStringKeyword = isTSStringKeyword;
generated$3.isTSSymbolKeyword = isTSSymbolKeyword;
generated$3.isTSTemplateLiteralType = isTSTemplateLiteralType;
generated$3.isTSThisType = isTSThisType;
generated$3.isTSTupleType = isTSTupleType;
generated$3.isTSType = isTSType;
generated$3.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
generated$3.isTSTypeAnnotation = isTSTypeAnnotation;
generated$3.isTSTypeAssertion = isTSTypeAssertion;
generated$3.isTSTypeElement = isTSTypeElement;
generated$3.isTSTypeLiteral = isTSTypeLiteral;
generated$3.isTSTypeOperator = isTSTypeOperator;
generated$3.isTSTypeParameter = isTSTypeParameter;
generated$3.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
generated$3.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
generated$3.isTSTypePredicate = isTSTypePredicate;
generated$3.isTSTypeQuery = isTSTypeQuery;
generated$3.isTSTypeReference = isTSTypeReference;
generated$3.isTSUndefinedKeyword = isTSUndefinedKeyword;
generated$3.isTSUnionType = isTSUnionType;
generated$3.isTSUnknownKeyword = isTSUnknownKeyword;
generated$3.isTSVoidKeyword = isTSVoidKeyword;
generated$3.isTaggedTemplateExpression = isTaggedTemplateExpression;
generated$3.isTemplateElement = isTemplateElement;
generated$3.isTemplateLiteral = isTemplateLiteral;
generated$3.isTerminatorless = isTerminatorless;
generated$3.isThisExpression = isThisExpression;
generated$3.isThisTypeAnnotation = isThisTypeAnnotation;
generated$3.isThrowStatement = isThrowStatement;
generated$3.isTopicReference = isTopicReference;
generated$3.isTryStatement = isTryStatement;
generated$3.isTupleExpression = isTupleExpression;
generated$3.isTupleTypeAnnotation = isTupleTypeAnnotation;
generated$3.isTypeAlias = isTypeAlias;
generated$3.isTypeAnnotation = isTypeAnnotation;
generated$3.isTypeCastExpression = isTypeCastExpression;
generated$3.isTypeParameter = isTypeParameter;
generated$3.isTypeParameterDeclaration = isTypeParameterDeclaration;
generated$3.isTypeParameterInstantiation = isTypeParameterInstantiation;
generated$3.isTypeScript = isTypeScript;
generated$3.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
generated$3.isUnaryExpression = isUnaryExpression;
generated$3.isUnaryLike = isUnaryLike;
generated$3.isUnionTypeAnnotation = isUnionTypeAnnotation;
generated$3.isUpdateExpression = isUpdateExpression;
generated$3.isUserWhitespacable = isUserWhitespacable;
generated$3.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;
generated$3.isVariableDeclaration = isVariableDeclaration;
generated$3.isVariableDeclarator = isVariableDeclarator;
generated$3.isVariance = isVariance;
generated$3.isVoidPattern = isVoidPattern;
generated$3.isVoidTypeAnnotation = isVoidTypeAnnotation;
generated$3.isWhile = isWhile;
generated$3.isWhileStatement = isWhileStatement;
generated$3.isWithStatement = isWithStatement;
generated$3.isYieldExpression = isYieldExpression;
var _shallowEqual = requireShallowEqual();
var _deprecationWarning = requireDeprecationWarning();
function isArrayExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ArrayExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isAssignmentExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "AssignmentExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isBinaryExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "BinaryExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isInterpreterDirective(node2, opts) {
if (!node2) return false;
if (node2.type !== "InterpreterDirective") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isDirective(node2, opts) {
if (!node2) return false;
if (node2.type !== "Directive") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isDirectiveLiteral(node2, opts) {
if (!node2) return false;
if (node2.type !== "DirectiveLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isBlockStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "BlockStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isBreakStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "BreakStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isCallExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "CallExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isCatchClause(node2, opts) {
if (!node2) return false;
if (node2.type !== "CatchClause") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isConditionalExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ConditionalExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isContinueStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ContinueStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isDebuggerStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "DebuggerStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isDoWhileStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "DoWhileStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isEmptyStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "EmptyStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isExpressionStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ExpressionStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isFile(node2, opts) {
if (!node2) return false;
if (node2.type !== "File") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isForInStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ForInStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isForStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ForStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isFunctionDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "FunctionDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isFunctionExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "FunctionExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isIdentifier(node2, opts) {
if (!node2) return false;
if (node2.type !== "Identifier") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isIfStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "IfStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isLabeledStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "LabeledStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isStringLiteral(node2, opts) {
if (!node2) return false;
if (node2.type !== "StringLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isNumericLiteral(node2, opts) {
if (!node2) return false;
if (node2.type !== "NumericLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isNullLiteral(node2, opts) {
if (!node2) return false;
if (node2.type !== "NullLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isBooleanLiteral(node2, opts) {
if (!node2) return false;
if (node2.type !== "BooleanLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isRegExpLiteral(node2, opts) {
if (!node2) return false;
if (node2.type !== "RegExpLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isLogicalExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "LogicalExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isMemberExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "MemberExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isNewExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "NewExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isProgram(node2, opts) {
if (!node2) return false;
if (node2.type !== "Program") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isObjectExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ObjectExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isObjectMethod(node2, opts) {
if (!node2) return false;
if (node2.type !== "ObjectMethod") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isObjectProperty(node2, opts) {
if (!node2) return false;
if (node2.type !== "ObjectProperty") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isRestElement(node2, opts) {
if (!node2) return false;
if (node2.type !== "RestElement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isReturnStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ReturnStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isSequenceExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "SequenceExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isParenthesizedExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ParenthesizedExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isSwitchCase(node2, opts) {
if (!node2) return false;
if (node2.type !== "SwitchCase") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isSwitchStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "SwitchStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isThisExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ThisExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isThrowStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ThrowStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isTryStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "TryStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isUnaryExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "UnaryExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isUpdateExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "UpdateExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isVariableDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "VariableDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isVariableDeclarator(node2, opts) {
if (!node2) return false;
if (node2.type !== "VariableDeclarator") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isWhileStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "WhileStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isWithStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "WithStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isAssignmentPattern(node2, opts) {
if (!node2) return false;
if (node2.type !== "AssignmentPattern") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isArrayPattern(node2, opts) {
if (!node2) return false;
if (node2.type !== "ArrayPattern") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isArrowFunctionExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ArrowFunctionExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isClassBody(node2, opts) {
if (!node2) return false;
if (node2.type !== "ClassBody") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isClassExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ClassExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isClassDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "ClassDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isExportAllDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "ExportAllDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isExportDefaultDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "ExportDefaultDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isExportNamedDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "ExportNamedDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isExportSpecifier(node2, opts) {
if (!node2) return false;
if (node2.type !== "ExportSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isForOfStatement(node2, opts) {
if (!node2) return false;
if (node2.type !== "ForOfStatement") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isImportDeclaration(node2, opts) {
if (!node2) return false;
if (node2.type !== "ImportDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isImportDefaultSpecifier(node2, opts) {
if (!node2) return false;
if (node2.type !== "ImportDefaultSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isImportNamespaceSpecifier(node2, opts) {
if (!node2) return false;
if (node2.type !== "ImportNamespaceSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isImportSpecifier(node2, opts) {
if (!node2) return false;
if (node2.type !== "ImportSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isImportExpression(node2, opts) {
if (!node2) return false;
if (node2.type !== "ImportExpression") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isMetaProperty(node2, opts) {
if (!node2) return false;
if (node2.type !== "MetaProperty") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isClassMethod(node2, opts) {
if (!node2) return false;
if (node2.type !== "ClassMethod") return false;
return opts == null || (0, _shallowEqual.default)(node2, opts);
}
function isObjectPattern(node2, opts) {
if (!node2) return false;
if (node2.type !== "ObjectPattern") return false;
ret