vaderjs 1.1.2 → 1.1.4

package/website/node_modules/sucrase/dist/types/transformers/CJSImportTransformer.d.ts

@@ -1,149 +0,0 @@
-import type CJSImportProcessor from "../CJSImportProcessor";
-import type { HelperManager } from "../HelperManager";
-import type NameManager from "../NameManager";
-import type TokenProcessor from "../TokenProcessor";
-import type ReactHotLoaderTransformer from "./ReactHotLoaderTransformer";
-import type RootTransformer from "./RootTransformer";
-import Transformer from "./Transformer";
-/**
- * Class for editing import statements when we are transforming to commonjs.
- */
-export default class CJSImportTransformer extends Transformer {
-    readonly rootTransformer: RootTransformer;
-    readonly tokens: TokenProcessor;
-    readonly importProcessor: CJSImportProcessor;
-    readonly nameManager: NameManager;
-    readonly helperManager: HelperManager;
-    readonly reactHotLoaderTransformer: ReactHotLoaderTransformer | null;
-    readonly enableLegacyBabel5ModuleInterop: boolean;
-    readonly enableLegacyTypeScriptModuleInterop: boolean;
-    readonly isTypeScriptTransformEnabled: boolean;
-    readonly isFlowTransformEnabled: boolean;
-    readonly preserveDynamicImport: boolean;
-    readonly keepUnusedImports: boolean;
-    private hadExport;
-    private hadNamedExport;
-    private hadDefaultExport;
-    private declarationInfo;
-    constructor(rootTransformer: RootTransformer, tokens: TokenProcessor, importProcessor: CJSImportProcessor, nameManager: NameManager, helperManager: HelperManager, reactHotLoaderTransformer: ReactHotLoaderTransformer | null, enableLegacyBabel5ModuleInterop: boolean, enableLegacyTypeScriptModuleInterop: boolean, isTypeScriptTransformEnabled: boolean, isFlowTransformEnabled: boolean, preserveDynamicImport: boolean, keepUnusedImports: boolean);
-    getPrefixCode(): string;
-    getSuffixCode(): string;
-    process(): boolean;
-    private processImportEquals;
-    /**
-     * Transform this:
-     * import foo, {bar} from 'baz';
-     * into
-     * var _baz = require('baz'); var _baz2 = _interopRequireDefault(_baz);
-     *
-     * The import code was already generated in the import preprocessing step, so
-     * we just need to look it up.
-     */
-    private processImport;
-    /**
-     * Erase this import (since any CJS output would be completely different), and
-     * return true if this import is should be elided due to being a type-only
-     * import. Such imports will not be emitted at all to avoid side effects.
-     *
-     * Import elision only happens with the TypeScript or Flow transforms enabled.
-     *
-     * TODO: This function has some awkward overlap with
-     *  CJSImportProcessor.pruneTypeOnlyImports , and the two should be unified.
-     *  That function handles TypeScript implicit import name elision, and removes
-     *  an import if all typical imported names (without `type`) are removed due
-     *  to being type-only imports. This function handles Flow import removal and
-     *  properly distinguishes `import 'foo'` from `import {} from 'foo'` for TS
-     *  purposes.
-     *
-     * The position should end at the import string.
-     */
-    private removeImportAndDetectIfShouldElide;
-    private removeRemainingImport;
-    private processIdentifier;
-    processObjectShorthand(): boolean;
-    processExport(): boolean;
-    private processAssignment;
-    /**
-     * Process something like `a += 3`, where `a` might be an exported value.
-     */
-    private processComplexAssignment;
-    /**
-     * Process something like `++a`, where `a` might be an exported value.
-     */
-    private processPreIncDec;
-    /**
-     * Process something like `a++`, where `a` might be an exported value.
-     * This starts at the `a`, not at the `++`.
-     */
-    private processPostIncDec;
-    private processExportDefault;
-    private copyDecorators;
-    /**
-     * Transform a declaration like `export var`, `export let`, or `export const`.
-     */
-    private processExportVar;
-    /**
-     * Determine if the export is of the form:
-     * export var/let/const [varName] = [expr];
-     * In other words, determine if function name inference might apply.
-     */
-    private isSimpleExportVar;
-    /**
-     * Transform an `export var` declaration initializing a single variable.
-     *
-     * For example, this:
-     * export const f = () => {};
-     * becomes this:
-     * const f = () => {}; exports.f = f;
-     *
-     * The variable is unused (e.g. exports.f has the true value of the export).
-     * We need to produce an assignment of this form so that the function will
-     * have an inferred name of "f", which wouldn't happen in the more general
-     * case below.
-     */
-    private processSimpleExportVar;
-    /**
-     * Transform normal declaration exports, including handling destructuring.
-     * For example, this:
-     * export const {x: [a = 2, b], c} = d;
-     * becomes this:
-     * ({x: [exports.a = 2, exports.b], c: exports.c} = d;)
-     */
-    private processComplexExportVar;
-    /**
-     * Transform this:
-     * export function foo() {}
-     * into this:
-     * function foo() {} exports.foo = foo;
-     */
-    private processExportFunction;
-    /**
-     * Skip past a function with a name and return that name.
-     */
-    private processNamedFunction;
-    /**
-     * Transform this:
-     * export class A {}
-     * into this:
-     * class A {} exports.A = A;
-     */
-    private processExportClass;
-    /**
-     * Transform this:
-     * export {a, b as c};
-     * into this:
-     * exports.a = a; exports.c = b;
-     *
-     * OR
-     *
-     * Transform this:
-     * export {a, b as c} from './foo';
-     * into the pre-generated Object.defineProperty code from the ImportProcessor.
-     *
-     * For the first case, if the TypeScript transform is enabled, we need to skip
-     * exports that are only defined as types.
-     */
-    private processExportBindings;
-    private processExportStar;
-    private shouldElideExportedIdentifier;
-}

package/website/node_modules/sucrase/dist/types/transformers/ESMImportTransformer.d.ts

@@ -1,52 +0,0 @@
-import type { HelperManager } from "../HelperManager";
-import type { Options } from "../index";
-import type NameManager from "../NameManager";
-import type TokenProcessor from "../TokenProcessor";
-import type ReactHotLoaderTransformer from "./ReactHotLoaderTransformer";
-import Transformer from "./Transformer";
-/**
- * Class for editing import statements when we are keeping the code as ESM. We still need to remove
- * type-only imports in TypeScript and Flow.
- */
-export default class ESMImportTransformer extends Transformer {
-    readonly tokens: TokenProcessor;
-    readonly nameManager: NameManager;
-    readonly helperManager: HelperManager;
-    readonly reactHotLoaderTransformer: ReactHotLoaderTransformer | null;
-    readonly isTypeScriptTransformEnabled: boolean;
-    readonly isFlowTransformEnabled: boolean;
-    readonly keepUnusedImports: boolean;
-    private nonTypeIdentifiers;
-    private declarationInfo;
-    private injectCreateRequireForImportRequire;
-    constructor(tokens: TokenProcessor, nameManager: NameManager, helperManager: HelperManager, reactHotLoaderTransformer: ReactHotLoaderTransformer | null, isTypeScriptTransformEnabled: boolean, isFlowTransformEnabled: boolean, keepUnusedImports: boolean, options: Options);
-    process(): boolean;
-    private processImportEquals;
-    private processImport;
-    /**
-     * Remove type bindings from this import, leaving the rest of the import intact.
-     *
-     * Return true if this import was ONLY types, and thus is eligible for removal. This will bail out
-     * of the replacement operation, so we can return early here.
-     */
-    private removeImportTypeBindings;
-    private shouldAutomaticallyElideImportedName;
-    private processExportDefault;
-    /**
-     * Handle a statement with one of these forms:
-     * export {a, type b};
-     * export {c, type d} from 'foo';
-     *
-     * In both cases, any explicit type exports should be removed. In the first
-     * case, we also need to handle implicit export elision for names declared as
-     * types. In the second case, we must NOT do implicit named export elision,
-     * but we must remove the runtime import if all exports are type exports.
-     */
-    private processNamedExports;
-    /**
-     * ESM elides all imports with the rule that we only elide if we see that it's
-     * a type and never see it as a value. This is in contrast to CJS, which
-     * elides imports that are completely unknown.
-     */
-    private shouldElideExportedName;
-}

package/website/node_modules/sucrase/dist/types/transformers/FlowTransformer.d.ts

@@ -1,79 +0,0 @@
-import type TokenProcessor from "../TokenProcessor";
-import type RootTransformer from "./RootTransformer";
-import Transformer from "./Transformer";
-export default class FlowTransformer extends Transformer {
-    readonly rootTransformer: RootTransformer;
-    readonly tokens: TokenProcessor;
-    readonly isImportsTransformEnabled: boolean;
-    constructor(rootTransformer: RootTransformer, tokens: TokenProcessor, isImportsTransformEnabled: boolean);
-    process(): boolean;
-    /**
-     * Handle a declaration like:
-     * export enum E ...
-     *
-     * With this imports transform, this becomes:
-     * const E = [[enum]]; exports.E = E;
-     *
-     * otherwise, it becomes:
-     * export const E = [[enum]];
-     */
-    processNamedExportEnum(): void;
-    /**
-     * Handle a declaration like:
-     * export default enum E
-     *
-     * With the imports transform, this becomes:
-     * const E = [[enum]]; exports.default = E;
-     *
-     * otherwise, it becomes:
-     * const E = [[enum]]; export default E;
-     */
-    processDefaultExportEnum(): void;
-    /**
-     * Transpile flow enums to invoke the "flow-enums-runtime" library.
-     *
-     * Currently, the transpiled code always uses `require("flow-enums-runtime")`,
-     * but if future flexibility is needed, we could expose a config option for
-     * this string (similar to configurable JSX). Even when targeting ESM, the
-     * default behavior of babel-plugin-transform-flow-enums is to use require
-     * rather than injecting an import.
-     *
-     * Flow enums are quite a bit simpler than TS enums and have some convenient
-     * constraints:
-     * - Element initializers must be either always present or always absent. That
-     *   means that we can use fixed lookahead on the first element (if any) and
-     *   assume that all elements are like that.
-     * - The right-hand side of an element initializer must be a literal value,
-     *   not a complex expression and not referencing other elements. That means
-     *   we can simply copy a single token.
-     *
-     * Enums can be broken up into three basic cases:
-     *
-     * Mirrored enums:
-     * enum E {A, B}
-     *   ->
-     * const E = require("flow-enums-runtime").Mirrored(["A", "B"]);
-     *
-     * Initializer enums:
-     * enum E {A = 1, B = 2}
-     *   ->
-     * const E = require("flow-enums-runtime")({A: 1, B: 2});
-     *
-     * Symbol enums:
-     * enum E of symbol {A, B}
-     *   ->
-     * const E = require("flow-enums-runtime")({A: Symbol("A"), B: Symbol("B")});
-     *
-     * We can statically detect which of the three cases this is by looking at the
-     * "of" declaration (if any) and seeing if the first element has an initializer.
-     * Since the other transform details are so similar between the three cases, we
-     * use a single implementation and vary the transform within processEnumElement
-     * based on case.
-     */
-    processEnum(): void;
-    /**
-     * Process an individual enum element, producing either an array element or an
-     * object element based on what type of enum this is.
-     */
-    processEnumElement(isSymbolEnum: boolean, hasInitializers: boolean): void;
-}

package/website/node_modules/sucrase/dist/types/transformers/JSXTransformer.d.ts

@@ -1,144 +0,0 @@
-import type CJSImportProcessor from "../CJSImportProcessor";
-import type { Options } from "../index";
-import type NameManager from "../NameManager";
-import { JSXRole } from "../parser/tokenizer";
-import type TokenProcessor from "../TokenProcessor";
-import { type JSXPragmaInfo } from "../util/getJSXPragmaInfo";
-import type RootTransformer from "./RootTransformer";
-import Transformer from "./Transformer";
-export default class JSXTransformer extends Transformer {
-    readonly rootTransformer: RootTransformer;
-    readonly tokens: TokenProcessor;
-    readonly importProcessor: CJSImportProcessor | null;
-    readonly nameManager: NameManager;
-    readonly options: Options;
-    jsxPragmaInfo: JSXPragmaInfo;
-    jsxImportSource: string;
-    isAutomaticRuntime: boolean;
-    lastLineNumber: number;
-    lastIndex: number;
-    filenameVarName: string | null;
-    esmAutomaticImportNameResolutions: {
-        [name: string]: string;
-    };
-    cjsAutomaticModuleNameResolutions: {
-        [path: string]: string;
-    };
-    constructor(rootTransformer: RootTransformer, tokens: TokenProcessor, importProcessor: CJSImportProcessor | null, nameManager: NameManager, options: Options);
-    process(): boolean;
-    getPrefixCode(): string;
-    processJSXTag(): void;
-    getElementLocationCode(firstTokenStart: number): string;
-    /**
-     * Get the line number for this source position. This is calculated lazily and
-     * must be called in increasing order by index.
-     */
-    getLineNumberForIndex(index: number): number;
-    /**
-     * Convert the current JSX element to a call to jsx, jsxs, or jsxDEV. This is
-     * the primary transformation for the automatic transform.
-     *
-     * Example:
-     * <div a={1} key={2}>Hello{x}</div>
-     * becomes
-     * jsxs('div', {a: 1, children: ["Hello", x]}, 2)
-     */
-    transformTagToJSXFunc(elementLocationCode: string | null, jsxRole: JSXRole): void;
-    /**
-     * Convert the current JSX element to a createElement call. In the classic
-     * runtime, this is the only case. In the automatic runtime, this is called
-     * as a fallback in some situations.
-     *
-     * Example:
-     * <div a={1} key={2}>Hello{x}</div>
-     * becomes
-     * React.createElement('div', {a: 1, key: 2}, "Hello", x)
-     */
-    transformTagToCreateElement(elementLocationCode: string | null): void;
-    /**
-     * Get the code for the relevant function for this context: jsx, jsxs,
-     * or jsxDEV. The following open-paren is included as well.
-     *
-     * These functions are only used for the automatic runtime, so they are always
-     * auto-imported, but the auto-import will be either CJS or ESM based on the
-     * target module format.
-     */
-    getJSXFuncInvocationCode(isStatic: boolean): string;
-    /**
-     * Return the code to use for the createElement function, e.g.
-     * `React.createElement`, including the following open-paren.
-     *
-     * This is the main function to use for the classic runtime. For the
-     * automatic runtime, this function is used as a fallback function to
-     * preserve behavior when there is a prop spread followed by an explicit
-     * key. In that automatic runtime case, the function should be automatically
-     * imported.
-     */
-    getCreateElementInvocationCode(): string;
-    /**
-     * Return the code to use as the component when compiling a shorthand
-     * fragment, e.g. `React.Fragment`.
-     *
-     * This may be called from either the classic or automatic runtime, and
-     * the value should be auto-imported for the automatic runtime.
-     */
-    getFragmentCode(): string;
-    /**
-     * Return code that invokes the given function.
-     *
-     * When the imports transform is enabled, use the CJSImportTransformer
-     * strategy of using `.call(void 0, ...` to avoid passing a `this` value in a
-     * situation that would otherwise look like a method call.
-     */
-    claimAutoImportedFuncInvocation(funcName: string, importPathSuffix: string): string;
-    claimAutoImportedName(funcName: string, importPathSuffix: string): string;
-    /**
-     * Process the first part of a tag, before any props.
-     */
-    processTagIntro(): void;
-    /**
-     * Starting at the beginning of the props, add the props argument to
-     * React.createElement, including the comma before it.
-     */
-    processPropsObjectWithDevInfo(elementLocationCode: string | null): void;
-    /**
-     * Transform the core part of the props, assuming that a { has already been
-     * inserted before us and that a } will be inserted after us.
-     *
-     * If extractKeyCode is true (i.e. when using any jsx... function), any prop
-     * named "key" has its code captured and returned rather than being emitted to
-     * the output code. This shifts line numbers, and emitting the code later will
-     * correct line numbers again. If no key is found or if extractKeyCode is
-     * false, this function returns null.
-     */
-    processProps(extractKeyCode: boolean): string | null;
-    processPropName(propName: string): void;
-    processPropValue(): void;
-    processStringPropValue(): void;
-    /**
-     * Starting in the middle of the props object literal, produce an additional
-     * prop for the children and close the object literal.
-     */
-    processAutomaticChildrenAndEndProps(jsxRole: JSXRole): void;
-    /**
-     * Transform children into a comma-separated list, which will be either
-     * arguments to createElement or array elements of a children prop.
-     */
-    processChildren(needsInitialComma: boolean): void;
-    /**
-     * Turn a JSX text element into a string literal, or nothing at all if the JSX
-     * text resolves to the empty string.
-     *
-     * Returns true if a string literal is emitted, false otherwise.
-     */
-    processChildTextElement(needsComma: boolean): boolean;
-    getDevSource(elementLocationCode: string): string;
-    getFilenameVarName(): string;
-}
-/**
- * Spec for identifiers: https://tc39.github.io/ecma262/#prod-IdentifierStart.
- *
- * Really only treat anything starting with a-z as tag names.  `_`, `$`, `é`
- * should be treated as component names
- */
-export declare function startsWithLowerCase(s: string): boolean;

package/website/node_modules/sucrase/dist/types/transformers/JestHoistTransformer.d.ts

@@ -1,32 +0,0 @@
-import type CJSImportProcessor from "../CJSImportProcessor";
-import type NameManager from "../NameManager";
-import type TokenProcessor from "../TokenProcessor";
-import type RootTransformer from "./RootTransformer";
-import Transformer from "./Transformer";
-/**
- * Implementation of babel-plugin-jest-hoist, which hoists up some jest method
- * calls above the imports to allow them to override other imports.
- *
- * To preserve line numbers, rather than directly moving the jest.mock code, we
- * wrap each invocation in a function statement and then call the function from
- * the top of the file.
- */
-export default class JestHoistTransformer extends Transformer {
-    readonly rootTransformer: RootTransformer;
-    readonly tokens: TokenProcessor;
-    readonly nameManager: NameManager;
-    readonly importProcessor: CJSImportProcessor | null;
-    private readonly hoistedFunctionNames;
-    constructor(rootTransformer: RootTransformer, tokens: TokenProcessor, nameManager: NameManager, importProcessor: CJSImportProcessor | null);
-    process(): boolean;
-    getHoistedCode(): string;
-    /**
-     * Extracts any methods calls on the jest-object that should be hoisted.
-     *
-     * According to the jest docs, https://jestjs.io/docs/en/jest-object#jestmockmodulename-factory-options,
-     * mock, unmock, enableAutomock, disableAutomock, are the methods that should be hoisted.
-     *
-     * We do not apply the same checks of the arguments as babel-plugin-jest-hoist does.
-     */
-    private extractHoistedCalls;
-}

package/website/node_modules/sucrase/dist/types/transformers/NumericSeparatorTransformer.d.ts

@@ -1,7 +0,0 @@
-import type TokenProcessor from "../TokenProcessor";
-import Transformer from "./Transformer";
-export default class NumericSeparatorTransformer extends Transformer {
-    readonly tokens: TokenProcessor;
-    constructor(tokens: TokenProcessor);
-    process(): boolean;
-}

package/website/node_modules/sucrase/dist/types/transformers/OptionalCatchBindingTransformer.d.ts

@@ -1,9 +0,0 @@
-import type NameManager from "../NameManager";
-import type TokenProcessor from "../TokenProcessor";
-import Transformer from "./Transformer";
-export default class OptionalCatchBindingTransformer extends Transformer {
-    readonly tokens: TokenProcessor;
-    readonly nameManager: NameManager;
-    constructor(tokens: TokenProcessor, nameManager: NameManager);
-    process(): boolean;
-}

package/website/node_modules/sucrase/dist/types/transformers/OptionalChainingNullishTransformer.d.ts

@@ -1,36 +0,0 @@
-import type NameManager from "../NameManager";
-import type TokenProcessor from "../TokenProcessor";
-import Transformer from "./Transformer";
-/**
- * Transformer supporting the optional chaining and nullish coalescing operators.
- *
- * Tech plan here:
- * https://github.com/alangpierce/sucrase/wiki/Sucrase-Optional-Chaining-and-Nullish-Coalescing-Technical-Plan
- *
- * The prefix and suffix code snippets are handled by TokenProcessor, and this transformer handles
- * the operators themselves.
- */
-export default class OptionalChainingNullishTransformer extends Transformer {
-    readonly tokens: TokenProcessor;
-    readonly nameManager: NameManager;
-    constructor(tokens: TokenProcessor, nameManager: NameManager);
-    process(): boolean;
-    /**
-     * Determine if the current token is the last of its chain, so that we know whether it's eligible
-     * to have a delete op inserted.
-     *
-     * We can do this by walking forward until we determine one way or another. Each
-     * isOptionalChainStart token must be paired with exactly one isOptionalChainEnd token after it in
-     * a nesting way, so we can track depth and walk to the end of the chain (the point where the
-     * depth goes negative) and see if any other subscript token is after us in the chain.
-     */
-    isLastSubscriptInChain(): boolean;
-    /**
-     * Determine if we are the open-paren in an expression like super.a()?.b.
-     *
-     * We can do this by walking backward to find the previous subscript. If that subscript was
-     * preceded by a super, then we must be the subscript after it, so if this is a call expression,
-     * we'll need to attach the right context.
-     */
-    justSkippedSuper(): boolean;
-}

package/website/node_modules/sucrase/dist/types/transformers/ReactDisplayNameTransformer.d.ts

@@ -1,29 +0,0 @@
-import type CJSImportProcessor from "../CJSImportProcessor";
-import type { Options } from "../index";
-import type TokenProcessor from "../TokenProcessor";
-import type RootTransformer from "./RootTransformer";
-import Transformer from "./Transformer";
-/**
- * Implementation of babel-plugin-transform-react-display-name, which adds a
- * display name to usages of React.createClass and createReactClass.
- */
-export default class ReactDisplayNameTransformer extends Transformer {
-    readonly rootTransformer: RootTransformer;
-    readonly tokens: TokenProcessor;
-    readonly importProcessor: CJSImportProcessor | null;
-    readonly options: Options;
-    constructor(rootTransformer: RootTransformer, tokens: TokenProcessor, importProcessor: CJSImportProcessor | null, options: Options);
-    process(): boolean;
-    /**
-     * This is called with the token position at the open-paren.
-     */
-    private tryProcessCreateClassCall;
-    private findDisplayName;
-    private getDisplayNameFromFilename;
-    /**
-     * We only want to add a display name when this is a function call containing
-     * one argument, which is an object literal without `displayName` as an
-     * existing key.
-     */
-    private classNeedsDisplayName;
-}

package/website/node_modules/sucrase/dist/types/transformers/ReactHotLoaderTransformer.d.ts

@@ -1,12 +0,0 @@
-import type TokenProcessor from "../TokenProcessor";
-import Transformer from "./Transformer";
-export default class ReactHotLoaderTransformer extends Transformer {
-    readonly tokens: TokenProcessor;
-    readonly filePath: string;
-    private extractedDefaultExportName;
-    constructor(tokens: TokenProcessor, filePath: string);
-    setExtractedDefaultExportName(extractedDefaultExportName: string): void;
-    getPrefixCode(): string;
-    getSuffixCode(): string;
-    process(): boolean;
-}

package/website/node_modules/sucrase/dist/types/transformers/RootTransformer.d.ts

@@ -1,52 +0,0 @@
-import type { Options, SucraseContext, Transform } from "../index";
-import { type ClassInfo } from "../util/getClassInfo";
-export interface RootTransformerResult {
-    code: string;
-    mappings: Array<number | undefined>;
-}
-export default class RootTransformer {
-    private transformers;
-    private nameManager;
-    private tokens;
-    private generatedVariables;
-    private isImportsTransformEnabled;
-    private isReactHotLoaderTransformEnabled;
-    private disableESTransforms;
-    private helperManager;
-    constructor(sucraseContext: SucraseContext, transforms: Array<Transform>, enableLegacyBabel5ModuleInterop: boolean, options: Options);
-    transform(): RootTransformerResult;
-    processBalancedCode(): void;
-    processToken(): void;
-    /**
-     * Skip past a class with a name and return that name.
-     */
-    processNamedClass(): string;
-    processClass(): void;
-    /**
-     * We want to just handle class fields in all contexts, since TypeScript supports them. Later,
-     * when some JS implementations support class fields, this should be made optional.
-     */
-    processClassBody(classInfo: ClassInfo, className: string | null): void;
-    makeConstructorInitCode(constructorInitializerStatements: Array<string>, instanceInitializerNames: Array<string>, className: string): string;
-    /**
-     * Normally it's ok to simply remove type tokens, but we need to be more careful when dealing with
-     * arrow function return types since they can confuse the parser. In that case, we want to move
-     * the close-paren to the same line as the arrow.
-     *
-     * See https://github.com/alangpierce/sucrase/issues/391 for more details.
-     */
-    processPossibleArrowParamEnd(): boolean;
-    /**
-     * An async arrow function might be of the form:
-     *
-     * async <
-     *   T
-     * >() => {}
-     *
-     * in which case, removing the type parameters will cause a syntax error. Detect this case and
-     * move the open-paren earlier.
-     */
-    processPossibleAsyncArrowWithTypeParams(): boolean;
-    processPossibleTypeRange(): boolean;
-    shiftMappings(mappings: Array<number | undefined>, prefixLength: number): Array<number | undefined>;
-}

package/website/node_modules/sucrase/dist/types/transformers/Transformer.d.ts

@@ -1,6 +0,0 @@
-export default abstract class Transformer {
-    abstract process(): boolean;
-    getPrefixCode(): string;
-    getHoistedCode(): string;
-    getSuffixCode(): string;
-}