84 lines
2.1 KiB
JavaScript
Executable File
84 lines
2.1 KiB
JavaScript
Executable File
// @flow
|
|
|
|
import { type Options } from "./options";
|
|
import {
|
|
hasPlugin,
|
|
validatePlugins,
|
|
mixinPluginNames,
|
|
mixinPlugins,
|
|
type PluginList,
|
|
} from "./plugin-utils";
|
|
import Parser from "./parser";
|
|
|
|
import { types as tokTypes } from "./tokenizer/types";
|
|
import "./tokenizer/context";
|
|
|
|
import type { Expression, File } from "./types";
|
|
|
|
export function parse(input: string, options?: Options): File {
|
|
if (options && options.sourceType === "unambiguous") {
|
|
options = {
|
|
...options,
|
|
};
|
|
try {
|
|
options.sourceType = "module";
|
|
const parser = getParser(options, input);
|
|
const ast = parser.parse();
|
|
|
|
// Rather than try to parse as a script first, we opt to parse as a module and convert back
|
|
// to a script where possible to avoid having to do a full re-parse of the input content.
|
|
if (!parser.sawUnambiguousESM) ast.program.sourceType = "script";
|
|
return ast;
|
|
} catch (moduleError) {
|
|
try {
|
|
options.sourceType = "script";
|
|
return getParser(options, input).parse();
|
|
} catch (scriptError) {}
|
|
|
|
throw moduleError;
|
|
}
|
|
} else {
|
|
return getParser(options, input).parse();
|
|
}
|
|
}
|
|
|
|
export function parseExpression(input: string, options?: Options): Expression {
|
|
const parser = getParser(options, input);
|
|
if (parser.options.strictMode) {
|
|
parser.state.strict = true;
|
|
}
|
|
return parser.getExpression();
|
|
}
|
|
|
|
export { tokTypes };
|
|
|
|
function getParser(options: ?Options, input: string): Parser {
|
|
let cls = Parser;
|
|
if (options && options.plugins) {
|
|
validatePlugins(options.plugins);
|
|
cls = getParserClass(options.plugins);
|
|
}
|
|
|
|
return new cls(options, input);
|
|
}
|
|
|
|
const parserClassCache: { [key: string]: Class<Parser> } = {};
|
|
|
|
/** Get a Parser class with plugins applied. */
|
|
function getParserClass(pluginsFromOptions: PluginList): Class<Parser> {
|
|
const pluginList = mixinPluginNames.filter(name =>
|
|
hasPlugin(pluginsFromOptions, name),
|
|
);
|
|
|
|
const key = pluginList.join("/");
|
|
let cls = parserClassCache[key];
|
|
if (!cls) {
|
|
cls = Parser;
|
|
for (const plugin of pluginList) {
|
|
cls = mixinPlugins[plugin](cls);
|
|
}
|
|
parserClassCache[key] = cls;
|
|
}
|
|
return cls;
|
|
}
|