@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/regexEmptyLazyQuantifiers.js

@@ -1,90 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { parseRegexpAst } from "./utils/parseRegexpAst.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/regexEmptyLazyQuantifiers.ts
-function* extractLazyEndQuantifiers(alternatives) {
-	for (const { elements } of alternatives) {
-		if (!elements.length) continue;
-		const last = elements.at(-1);
-		if (!last) continue;
-		switch (last.type) {
-			case "CapturingGroup":
-			case "Group":
-				yield* extractLazyEndQuantifiers(last.alternatives);
-				break;
-			case "Quantifier":
-				if (!last.greedy && last.min !== last.max) yield last;
-				else if (last.max === 1) {
-					const element = last.element;
-					if (element.type === "Group" || element.type === "CapturingGroup") yield* extractLazyEndQuantifiers(element.alternatives);
-				}
-				break;
-			default: break;
-		}
-	}
-}
-var regexEmptyLazyQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports lazy quantifiers at the end of regular expressions.",
-		id: "regexEmptyLazyQuantifiers",
-		presets: ["logical"]
-	},
-	messages: {
-		uselessElement: {
-			primary: "Lazy quantifier '{{ raw }}' at end of pattern will only match the empty string.",
-			secondary: ["Lazy quantifiers at the end of a pattern with minimum 0 will match nothing because there's nothing after them to satisfy."],
-			suggestions: ["Remove the lazy quantifier.", "Add characters after the lazy quantifier to make it useful."]
-		},
-		uselessQuantifier: {
-			primary: "Lazy quantifier '{{ raw }}' at end of pattern will always match exactly once.",
-			secondary: ["Lazy quantifiers at the end of a pattern with minimum 1 will match exactly once because there's nothing after them to satisfy."],
-			suggestions: ["Remove the lazy quantifier.", "Add characters after the lazy quantifier to make it useful."]
-		},
-		uselessRange: {
-			primary: "Lazy quantifier '{{ raw }}' at end of pattern will always match exactly {{ min }} times.",
-			secondary: ["Lazy quantifiers at the end of a pattern will match only their minimum because there's nothing after them to satisfy."],
-			suggestions: ["Remove the lazy quantifier.", "Add characters after the lazy quantifier to make it useful."]
-		}
-	},
-	setup(context) {
-		function checkPattern(pattern, patternStart, flags) {
-			const regexpAst = parseRegexpAst(pattern, flags);
-			if (!regexpAst) return;
-			visitRegExpAST(regexpAst, { onPatternEnter(patternNode) {
-				for (const lazy of extractLazyEndQuantifiers(patternNode.alternatives)) {
-					const messageId = lazy.min === 0 ? "uselessElement" : lazy.min === 1 ? "uselessQuantifier" : "uselessRange";
-					context.report({
-						data: {
-							min: lazy.min,
-							raw: lazy.raw
-						},
-						message: messageId,
-						range: {
-							begin: patternStart + lazy.start,
-							end: patternStart + lazy.end
-						}
-					});
-				}
-			} });
-		}
-		function checkRegexLiteral(node, services) {
-			const details = getRegExpLiteralDetails(node, services);
-			checkPattern(details.pattern, details.start, details.flags);
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			checkPattern(construction.pattern, construction.start + 1, construction.flags);
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexEmptyLazyQuantifiers_default as default };

package/lib/rules/regexEmptyLookaroundsAssertions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty lookahead and lookbehind assertions in regular expressions.";
-    readonly id: "regexEmptyLookaroundsAssertions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyLookaround", undefined>;
-export default _default;

package/lib/rules/regexEmptyLookaroundsAssertions.js

@@ -1,66 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { parseRegexpAst } from "./utils/parseRegexpAst.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { visitRegExpAST } from "@eslint-community/regexpp";
-import { isPotentiallyEmpty } from "regexp-ast-analysis";
-//#region src/rules/regexEmptyLookaroundsAssertions.ts
-var regexEmptyLookaroundsAssertions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty lookahead and lookbehind assertions in regular expressions.",
-		id: "regexEmptyLookaroundsAssertions",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { emptyLookaround: {
-		primary: "Empty {{ kind }} will trivially {{ result }} all inputs.",
-		secondary: ["Empty lookaround assertions match the empty string and will always succeed (or fail if negated) without checking anything meaningful."],
-		suggestions: []
-	} },
-	setup(context) {
-		function checkPattern(pattern, patternStart, flagsText) {
-			const regexpAst = parseRegexpAst(pattern, flagsText);
-			if (!regexpAst) return;
-			const flags = {
-				dotAll: flagsText.includes("s"),
-				global: flagsText.includes("g"),
-				hasIndices: flagsText.includes("d"),
-				ignoreCase: flagsText.includes("i"),
-				multiline: flagsText.includes("m"),
-				sticky: flagsText.includes("y"),
-				unicode: flagsText.includes("u"),
-				unicodeSets: flagsText.includes("v")
-			};
-			visitRegExpAST(regexpAst, { onAssertionEnter(assertion) {
-				if (assertion.kind !== "lookahead" && assertion.kind !== "lookbehind") return;
-				if (isPotentiallyEmpty(assertion.alternatives, flags)) context.report({
-					data: {
-						kind: assertion.kind,
-						result: assertion.negate ? "reject" : "accept"
-					},
-					message: "emptyLookaround",
-					range: {
-						begin: patternStart + assertion.start,
-						end: patternStart + assertion.end
-					}
-				});
-			} });
-		}
-		function checkRegexLiteral(node, services) {
-			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
-			checkPattern(pattern, start, flags);
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			checkPattern(construction.pattern.replace(/\\\\/g, "\\"), construction.start + 1, construction.flags);
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexEmptyLookaroundsAssertions_default as default };

package/lib/rules/regexEmptyStringLiterals.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty string literals in character classes.";
-    readonly id: "regexEmptyStringLiterals";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyStringLiteral", undefined>;
-export default _default;

package/lib/rules/regexEmptyStringLiterals.js

@@ -1,64 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/regexEmptyStringLiterals.ts
-function findEmptyStringLiterals(pattern, flags) {
-	const results = [];
-	if (!flags.includes("v")) return results;
-	let ast;
-	try {
-		ast = parseRegExpLiteral(new RegExp(pattern, flags));
-	} catch {
-		return results;
-	}
-	visitRegExpAST(ast, { onClassStringDisjunctionEnter(node) {
-		if (node.alternatives.every((alternative) => !alternative.elements.length)) results.push(node);
-	} });
-	return results;
-}
-var regexEmptyStringLiterals_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty string literals in character classes.",
-		id: "regexEmptyStringLiterals",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { emptyStringLiteral: {
-		primary: "This empty string literal in a character class will always match the empty string.",
-		secondary: ["The `\\q{}` string literal matches the empty string.", "This generally either does not benefit the regular expression or can cause unintended matches."],
-		suggestions: ["Remove the empty string literal if this was unintentional.", "Use a quantifier on the character class if this was intentional."]
-	} },
-	setup(context) {
-		function checkRegexLiteral(node, services) {
-			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
-			const emptyLiterals = findEmptyStringLiterals(pattern, flags);
-			for (const literal of emptyLiterals) context.report({
-				message: "emptyStringLiteral",
-				range: {
-					begin: start + literal.start - 1,
-					end: start + literal.end - 1
-				}
-			});
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			const emptyLiterals = findEmptyStringLiterals(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
-			for (const literal of emptyLiterals) context.report({
-				message: "emptyStringLiteral",
-				range: {
-					begin: construction.start + literal.start,
-					end: construction.start + literal.end
-				}
-			});
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexEmptyStringLiterals_default as default };

package/lib/rules/regexEscapeBackspaces.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports escape backspace (`[\\b]`) in character classes.";
-    readonly id: "regexEscapeBackspaces";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "escapeBackspace", undefined>;
-export default _default;

package/lib/rules/regexEscapeBackspaces.js

@@ -1,67 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/regexEscapeBackspaces.ts
-function findEscapeBackspaces(pattern, flags) {
-	const results = [];
-	let ast;
-	try {
-		ast = parseRegExpLiteral(new RegExp(pattern, flags));
-	} catch {
-		return results;
-	}
-	visitRegExpAST(ast, { onCharacterEnter(node) {
-		if (node.raw === "\\b") results.push(node);
-	} });
-	return results;
-}
-var regexEscapeBackspaces_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports escape backspace (`[\\b]`) in character classes.",
-		id: "regexEscapeBackspaces",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { escapeBackspace: {
-		primary: "Prefer the clearer `\\u0008` instead of `[\\b]` for backspace character.",
-		secondary: [
-			"The `\\b` inside a character class matches the backspace character (U+0008).",
-			"Outside a character class, `\\b` is a word boundary assertion.",
-			"Using `\\u0008` makes the intent clearer."
-		],
-		suggestions: ["Replace `\\b` with `\\u0008`."]
-	} },
-	setup(context) {
-		function checkRegexLiteral(node, services) {
-			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
-			const backspaces = findEscapeBackspaces(pattern, flags);
-			for (const backspace of backspaces) context.report({
-				message: "escapeBackspace",
-				range: {
-					begin: start + backspace.start - 1,
-					end: start + backspace.end - 1
-				}
-			});
-		}
-		function checkRegExpConstructor(node, services) {
-			const construction = getRegExpConstruction(node, services);
-			if (!construction) return;
-			const backspaces = findEscapeBackspaces(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
-			for (const backspace of backspaces) context.report({
-				message: "escapeBackspace",
-				range: {
-					begin: construction.start + backspace.start,
-					end: construction.start + backspace.end
-				}
-			});
-		}
-		return { visitors: {
-			CallExpression: checkRegExpConstructor,
-			NewExpression: checkRegExpConstructor,
-			RegularExpressionLiteral: checkRegexLiteral
-		} };
-	}
-});
-//#endregion
-export { regexEscapeBackspaces_default as default };

package/lib/rules/regexExecutors.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports String.prototype.match calls that can be replaced with RegExp.prototype.exec.";
-    readonly id: "regexExecutors";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferExec", undefined>;
-export default _default;

package/lib/rules/regexExecutors.js

@@ -1,56 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { getStaticStringValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/regexExecutors.ts
-function getRegexFlags(node, sourceFile) {
-	switch (node.kind) {
-		case ts.SyntaxKind.CallExpression:
-		case ts.SyntaxKind.NewExpression:
-			if (ts.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments) {
-				if (node.arguments.length < 2) return "";
-				const flagsArg = node.arguments[1];
-				if (flagsArg) return getStaticStringValue(flagsArg);
-			}
-			return;
-		case ts.SyntaxKind.RegularExpressionLiteral: {
-			const text = node.getText(sourceFile);
-			const lastSlash = text.lastIndexOf("/");
-			return lastSlash >= 0 ? text.slice(lastSlash + 1) : "";
-		}
-		default: return;
-	}
-}
-var regexExecutors_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports String.prototype.match calls that can be replaced with RegExp.prototype.exec.",
-		id: "regexExecutors",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferExec: {
-		primary: "For consistency, prefer `RegExp.prototype.exec()` over `String.prototype.match()` when not using the global flag.",
-		secondary: ["`RegExp.prototype.exec()` is functionally identical to and slightly fewer characters than `String.prototype.match()` when the regex has no global flag.", "Choosing one by default leads to more consistent and therefore more readable code."],
-		suggestions: ["Switch from `String.prototype.match()` to `RegExp.prototype.exec()`.", "Add the global flag to the regular expression."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "match" || node.arguments.length < 1 || !(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
-			const firstArgument = node.arguments[0];
-			if (!(typeChecker.getTypeAtLocation(node.expression.expression).flags & ts.TypeFlags.StringLike)) return;
-			const flags = getRegexFlags(firstArgument, sourceFile);
-			if (flags === void 0 || flags.includes("g")) return;
-			const range = getTSNodeRange(node, sourceFile);
-			const regexText = firstArgument.getText(sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: `${regexText}.exec(${node.expression.expression.getText(sourceFile)})`
-				},
-				message: "preferExec",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { regexExecutors_default as default };

package/lib/rules/regexGraphemeStringLiterals.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports string literals inside character classes with the `v` flag that contain multiple graphemes.";
-    readonly id: "regexGraphemeStringLiterals";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "multipleGraphemes", undefined>;
-export default _default;

package/lib/rules/regexGraphemeStringLiterals.js

@@ -1,49 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { parseRegexpAst } from "./utils/parseRegexpAst.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/regexGraphemeStringLiterals.ts
-const segmenter = new Intl.Segmenter();
-function buildAlternativeExample(stringAlternative) {
-	return `(?:${stringAlternative.parent.alternatives.filter(isMultipleGraphemes).map((alternative) => alternative.raw).join("|")}|[...])`;
-}
-function isMultipleGraphemes(stringAlternative) {
-	if (stringAlternative.elements.length <= 1) return false;
-	const string = String.fromCodePoint(...stringAlternative.elements.map((element) => element.value));
-	return [...segmenter.segment(string)].length > 1;
-}
-var regexGraphemeStringLiterals_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports string literals inside character classes with the `v` flag that contain multiple graphemes.",
-		id: "regexGraphemeStringLiterals",
-		presets: ["stylisticStrict"]
-	},
-	messages: { multipleGraphemes: {
-		primary: "This literal contains multiple graphemes in the `\\q{}` matcher intended for single graphemes.",
-		secondary: ["The `\\q{}` syntax is designed for single extended grapheme clusters like emoji sequences.", "Using it for multiple \"graphemes\" (visual characters) is often a mistake."],
-		suggestions: ["If matching multi-character strings, consider using alternation: '{{ alternative }}'."]
-	} },
-	setup(context) {
-		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
-			const text = node.getText(sourceFile);
-			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
-			if (!match) return;
-			const [, pattern, flags] = match;
-			if (!pattern || !flags?.includes("v")) return;
-			const regexpAst = parseRegexpAst(pattern, flags);
-			if (!regexpAst) return;
-			const nodeRange = getTSNodeRange(node, sourceFile);
-			visitRegExpAST(regexpAst, { onStringAlternativeEnter(stringAlternative) {
-				if (!isMultipleGraphemes(stringAlternative)) return;
-				const alternative = buildAlternativeExample(stringAlternative);
-				context.report({
-					data: { alternative },
-					message: "multipleGraphemes",
-					range: nodeRange
-				});
-			} });
-		} } };
-	}
-});
-//#endregion
-export { regexGraphemeStringLiterals_default as default };

package/lib/rules/regexHexadecimalEscapes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.";
-    readonly id: "regexHexadecimalEscapes";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferHexEscape", undefined>;
-export default _default;

package/lib/rules/regexHexadecimalEscapes.js

@@ -1,69 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { parseRegexpAst } from "./utils/parseRegexpAst.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/regexHexadecimalEscapes.ts
-function getEscapeType(raw) {
-	if (raw.length === 1) return "literal";
-	if (!raw.startsWith("\\")) return;
-	const second = raw[1];
-	if (second === "x") return "hexadecimal";
-	if (second === "u") return "unicode";
-	if (second === "c") return "control";
-	if (second !== void 0 && second >= "0" && second <= "7") return "octal";
-}
-function toHexEscape(codePoint) {
-	return `\\x${codePoint.toString(16).padStart(2, "0")}`;
-}
-var regexHexadecimalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.",
-		id: "regexHexadecimalEscapes",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferHexEscape: {
-		primary: "Prefer the more succinct hexadecimal escape `{{ hexEscape }}` over {{ escapeType }} escape `{{ found }}`.",
-		secondary: ["Hexadecimal escapes are more concise for characters in the 0x00-0xFF range."],
-		suggestions: ["Replace `{{ found }}` with `{{ hexEscape }}`."]
-	} },
-	setup(context) {
-		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
-			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(node.text);
-			if (!match) return;
-			const [, pattern, flagsStr] = match;
-			if (!pattern) return;
-			const regexpAst = parseRegexpAst(pattern, flagsStr);
-			if (!regexpAst) return;
-			const range = getTSNodeRange(node, sourceFile);
-			visitRegExpAST(regexpAst, { onCharacterEnter(charNode) {
-				if (charNode.value > 255) return;
-				const escapeType = getEscapeType(charNode.raw);
-				if (!escapeType) return;
-				if (escapeType === "unicode" && (charNode.raw.startsWith("\\u00") || charNode.raw.startsWith("\\u{") && charNode.value <= 255)) {
-					const hexEscape = toHexEscape(charNode.value);
-					context.report({
-						data: {
-							escapeType,
-							found: charNode.raw,
-							hexEscape
-						},
-						fix: {
-							range: {
-								begin: range.begin + 1 + charNode.start,
-								end: range.begin + 1 + charNode.end
-							},
-							text: hexEscape
-						},
-						message: "preferHexEscape",
-						range: {
-							begin: range.begin + 1 + charNode.start,
-							end: range.begin + 1 + charNode.end
-						}
-					});
-				}
-			} });
-		} } };
-	}
-});
-//#endregion
-export { regexHexadecimalEscapes_default as default };

package/lib/rules/regexIgnoreCaseFlags.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports regex patterns that can be simplified by using the i (ignore case) flag.";
-    readonly id: "regexIgnoreCaseFlags";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useIgnoreCase", undefined>;
-export default _default;