first commit
This commit is contained in:
monjack
10
app_vue/node_modules/es-module-lexer/LICENSE
generated
vendored
Normal file
10
app_vue/node_modules/es-module-lexer/LICENSE
generated
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
MIT License
|
||||
-----------
|
||||
|
||||
Copyright (C) 2018-2022 Guy Bedford
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
338
app_vue/node_modules/es-module-lexer/README.md
generated
vendored
Normal file
338
app_vue/node_modules/es-module-lexer/README.md
generated
vendored
Normal file
@ -0,0 +1,338 @@
|
||||
# ES Module Lexer
|
||||
|
||||
[![Build Status][actions-image]][actions-url]
|
||||
|
||||
A JS module syntax lexer used in [es-module-shims](https://github.com/guybedford/es-module-shims).
|
||||
|
||||
Outputs the list of exports and locations of import specifiers, including dynamic import and import meta handling.
|
||||
|
||||
Supports new syntax features including import attributes and source phase imports.
|
||||
|
||||
A very small single JS file (4KiB gzipped) that includes inlined Web Assembly for very fast source analysis of ECMAScript module syntax only.
|
||||
|
||||
For an example of the performance, Angular 1 (720KiB) is fully parsed in 5ms, in comparison to the fastest JS parser, Acorn which takes over 100ms.
|
||||
|
||||
_Comprehensively handles the JS language grammar while remaining small and fast. - ~10ms per MB of JS cold and ~5ms per MB of JS warm, [see benchmarks](#benchmarks) for more info._
|
||||
|
||||
> [Built with](https://github.com/guybedford/es-module-lexer/blob/main/chompfile.toml) [Chomp](https://chompbuild.com/)
|
||||
|
||||
### Usage
|
||||
|
||||
```
|
||||
npm install es-module-lexer
|
||||
```
|
||||
|
||||
See [src/lexer.ts](src/lexer.ts) for the type definitions.
|
||||
|
||||
For use in CommonJS:
|
||||
|
||||
```js
|
||||
const { init, parse } = require('es-module-lexer');
|
||||
|
||||
(async () => {
|
||||
// either await init, or call parse asynchronously
|
||||
// this is necessary for the Web Assembly boot
|
||||
await init;
|
||||
|
||||
const source = 'export var p = 5';
|
||||
const [imports, exports] = parse(source);
|
||||
|
||||
// Returns "p"
|
||||
source.slice(exports[0].s, exports[0].e);
|
||||
// Returns "p"
|
||||
source.slice(exports[0].ls, exports[0].le);
|
||||
})();
|
||||
```
|
||||
|
||||
An ES module version is also available:
|
||||
|
||||
```js
|
||||
import { init, parse } from 'es-module-lexer';
|
||||
|
||||
(async () => {
|
||||
await init;
|
||||
|
||||
const source = `
|
||||
import { name } from 'mod\\u1011';
|
||||
import json from './json.json' assert { type: 'json' }
|
||||
export var p = 5;
|
||||
export function q () {
|
||||
|
||||
};
|
||||
export { x as 'external name' } from 'external';
|
||||
|
||||
// Comments provided to demonstrate edge cases
|
||||
import /*comment!*/ ( 'asdf', { assert: { type: 'json' }});
|
||||
import /*comment!*/.meta.asdf;
|
||||
|
||||
// Source phase imports:
|
||||
import source mod from './mod.wasm';
|
||||
import.source('./mod.wasm');
|
||||
`;
|
||||
|
||||
const [imports, exports] = parse(source, 'optional-sourcename');
|
||||
|
||||
// Returns "modထ"
|
||||
imports[0].n
|
||||
// Returns "mod\u1011"
|
||||
source.slice(imports[0].s, imports[0].e);
|
||||
// "s" = start
|
||||
// "e" = end
|
||||
|
||||
// Returns "import { name } from 'mod'"
|
||||
source.slice(imports[0].ss, imports[0].se);
|
||||
// "ss" = statement start
|
||||
// "se" = statement end
|
||||
|
||||
// Returns "{ type: 'json' }"
|
||||
source.slice(imports[1].a, imports[1].se);
|
||||
// "a" = assert, -1 for no assertion
|
||||
|
||||
// Returns "external"
|
||||
source.slice(imports[2].s, imports[2].e);
|
||||
|
||||
// Returns "p"
|
||||
source.slice(exports[0].s, exports[0].e);
|
||||
// Returns "p"
|
||||
source.slice(exports[0].ls, exports[0].le);
|
||||
// Returns "q"
|
||||
source.slice(exports[1].s, exports[1].e);
|
||||
// Returns "q"
|
||||
source.slice(exports[1].ls, exports[1].le);
|
||||
// Returns "'external name'"
|
||||
source.slice(exports[2].s, exports[2].e);
|
||||
// Returns -1
|
||||
exports[2].ls;
|
||||
// Returns -1
|
||||
exports[2].le;
|
||||
|
||||
// Import type is provided by `t` value
|
||||
// (1 for static, 2, for dynamic)
|
||||
// Returns true
|
||||
imports[2].t == 2;
|
||||
|
||||
// Returns "asdf" (only for string literal dynamic imports)
|
||||
imports[2].n
|
||||
// Returns "import /*comment!*/ ( 'asdf', { assert: { type: 'json' } })"
|
||||
source.slice(imports[3].ss, imports[3].se);
|
||||
// Returns "'asdf'"
|
||||
source.slice(imports[3].s, imports[3].e);
|
||||
// Returns "( 'asdf', { assert: { type: 'json' } })"
|
||||
source.slice(imports[3].d, imports[3].se);
|
||||
// Returns "{ assert: { type: 'json' } }"
|
||||
source.slice(imports[3].a, imports[3].se - 1);
|
||||
|
||||
// For non-string dynamic import expressions:
|
||||
// - n will be undefined
|
||||
// - a is currently -1 even if there is an assertion
|
||||
// - e is currently the character before the closing )
|
||||
|
||||
// For nested dynamic imports, the se value of the outer import is -1 as end tracking does not
|
||||
// currently support nested dynamic immports
|
||||
|
||||
// import.meta is indicated by imports[3].d === -2
|
||||
// Returns true
|
||||
imports[4].d === -2;
|
||||
// Returns "import /*comment!*/.meta"
|
||||
source.slice(imports[4].s, imports[4].e);
|
||||
// ss and se are the same for import meta
|
||||
|
||||
// Returns "'./mod.wasm'"
|
||||
source.slice(imports[5].s, imports[5].e);
|
||||
|
||||
// Import type 4 and 5 for static and dynamic source phase
|
||||
imports[5].t === 4;
|
||||
imports[6].t === 5;
|
||||
})();
|
||||
```
|
||||
|
||||
### CSP asm.js Build
|
||||
|
||||
The default version of the library uses Wasm and (safe) eval usage for performance and a minimal footprint.
|
||||
|
||||
Neither of these represent security escalation possibilities since there are no execution string injection vectors, but that can still violate existing CSP policies for applications.
|
||||
|
||||
For a version that works with CSP eval disabled, use the `es-module-lexer/js` build:
|
||||
|
||||
```js
|
||||
import { parse } from 'es-module-lexer/js';
|
||||
```
|
||||
|
||||
Instead of Web Assembly, this uses an asm.js build which is almost as fast as the Wasm version ([see benchmarks below](#benchmarks)).
|
||||
|
||||
### Escape Sequences
|
||||
|
||||
To handle escape sequences in specifier strings, the `.n` field of imported specifiers will be provided where possible.
|
||||
|
||||
For dynamic import expressions, this field will be empty if not a valid JS string.
|
||||
|
||||
### Facade Detection
|
||||
|
||||
Facade modules that only use import / export syntax can be detected via the third return value:
|
||||
|
||||
```js
|
||||
const [,, facade] = parse(`
|
||||
export * from 'external';
|
||||
import * as ns from 'external2';
|
||||
export { a as b } from 'external3';
|
||||
export { ns };
|
||||
`);
|
||||
facade === true;
|
||||
```
|
||||
|
||||
### ESM Detection
|
||||
|
||||
Modules that uses ESM syntaxes can be detected via the fourth return value:
|
||||
|
||||
```js
|
||||
const [,,, hasModuleSyntax] = parse(`
|
||||
export {}
|
||||
`);
|
||||
hasModuleSyntax === true;
|
||||
```
|
||||
|
||||
Dynamic imports are ignored since they can be used in Non-ESM files.
|
||||
|
||||
```js
|
||||
const [,,, hasModuleSyntax] = parse(`
|
||||
import('./foo.js')
|
||||
`);
|
||||
hasModuleSyntax === false;
|
||||
```
|
||||
|
||||
### Environment Support
|
||||
|
||||
Node.js 10+, and [all browsers with Web Assembly support](https://caniuse.com/#feat=wasm).
|
||||
|
||||
### Grammar Support
|
||||
|
||||
* Token state parses all line comments, block comments, strings, template strings, blocks, parens and punctuators.
|
||||
* Division operator / regex token ambiguity is handled via backtracking checks against punctuator prefixes, including closing brace or paren backtracking.
|
||||
* Always correctly parses valid JS source, but may parse invalid JS source without errors.
|
||||
|
||||
### Limitations
|
||||
|
||||
The lexing approach is designed to deal with the full language grammar including RegEx / division operator ambiguity through backtracking and paren / brace tracking.
|
||||
|
||||
The only limitation to the reduced parser is that the "exports" list may not correctly gather all export identifiers in the following edge cases:
|
||||
|
||||
```js
|
||||
// Only "a" is detected as an export, "q" isn't
|
||||
export var a = 'asdf', q = z;
|
||||
|
||||
// "b" is not detected as an export
|
||||
export var { a: b } = asdf;
|
||||
```
|
||||
|
||||
The above cases are handled gracefully in that the lexer will keep going fine, it will just not properly detect the export names above.
|
||||
|
||||
### Benchmarks
|
||||
|
||||
Benchmarks can be run with `npm run bench`.
|
||||
|
||||
Current results for a high spec machine:
|
||||
|
||||
#### Wasm Build
|
||||
|
||||
```
|
||||
Module load time
|
||||
> 5ms
|
||||
Cold Run, All Samples
|
||||
test/samples/*.js (3123 KiB)
|
||||
> 18ms
|
||||
|
||||
Warm Runs (average of 25 runs)
|
||||
test/samples/angular.js (739 KiB)
|
||||
> 3ms
|
||||
test/samples/angular.min.js (188 KiB)
|
||||
> 1ms
|
||||
test/samples/d3.js (508 KiB)
|
||||
> 3ms
|
||||
test/samples/d3.min.js (274 KiB)
|
||||
> 2ms
|
||||
test/samples/magic-string.js (35 KiB)
|
||||
> 0ms
|
||||
test/samples/magic-string.min.js (20 KiB)
|
||||
> 0ms
|
||||
test/samples/rollup.js (929 KiB)
|
||||
> 4.32ms
|
||||
test/samples/rollup.min.js (429 KiB)
|
||||
> 2.16ms
|
||||
|
||||
Warm Runs, All Samples (average of 25 runs)
|
||||
test/samples/*.js (3123 KiB)
|
||||
> 14.16ms
|
||||
```
|
||||
|
||||
#### JS Build (asm.js)
|
||||
|
||||
```
|
||||
Module load time
|
||||
> 2ms
|
||||
Cold Run, All Samples
|
||||
test/samples/*.js (3123 KiB)
|
||||
> 34ms
|
||||
|
||||
Warm Runs (average of 25 runs)
|
||||
test/samples/angular.js (739 KiB)
|
||||
> 3ms
|
||||
test/samples/angular.min.js (188 KiB)
|
||||
> 1ms
|
||||
test/samples/d3.js (508 KiB)
|
||||
> 3ms
|
||||
test/samples/d3.min.js (274 KiB)
|
||||
> 2ms
|
||||
test/samples/magic-string.js (35 KiB)
|
||||
> 0ms
|
||||
test/samples/magic-string.min.js (20 KiB)
|
||||
> 0ms
|
||||
test/samples/rollup.js (929 KiB)
|
||||
> 5ms
|
||||
test/samples/rollup.min.js (429 KiB)
|
||||
> 3.04ms
|
||||
|
||||
Warm Runs, All Samples (average of 25 runs)
|
||||
test/samples/*.js (3123 KiB)
|
||||
> 17.12ms
|
||||
```
|
||||
|
||||
### Building
|
||||
|
||||
This project uses [Chomp](https://chompbuild.com) for building.
|
||||
|
||||
With Chomp installed, download the WASI SDK 12.0 from https://github.com/WebAssembly/wasi-sdk/releases/tag/wasi-sdk-12.
|
||||
|
||||
- [Linux](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz)
|
||||
- [Windows (MinGW)](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-mingw.tar.gz)
|
||||
- [macOS](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-macos.tar.gz)
|
||||
|
||||
Locate the WASI-SDK as a sibling folder, or customize the path via the `WASI_PATH` environment variable.
|
||||
|
||||
Emscripten emsdk is also assumed to be a sibling folder or via the `EMSDK_PATH` environment variable.
|
||||
|
||||
Example setup:
|
||||
|
||||
```
|
||||
git clone https://github.com:guybedford/es-module-lexer
|
||||
git clone https://github.com/emscripten-core/emsdk
|
||||
cd emsdk
|
||||
git checkout 1.40.1-fastcomp
|
||||
./emsdk install 1.40.1-fastcomp
|
||||
cd ..
|
||||
wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz
|
||||
gunzip wasi-sdk-12.0-linux.tar.gz
|
||||
tar -xf wasi-sdk-12.0-linux.tar
|
||||
mv wasi-sdk-12.0-linux.tar wasi-sdk-12.0
|
||||
cargo install chompbuild
|
||||
cd es-module-lexer
|
||||
chomp test
|
||||
```
|
||||
|
||||
For the `asm.js` build, git clone `emsdk` from is assumed to be a sibling folder as well.
|
||||
|
||||
### License
|
||||
|
||||
MIT
|
||||
|
||||
[actions-image]: https://github.com/guybedford/es-module-lexer/actions/workflows/build.yml/badge.svg
|
||||
[actions-url]: https://github.com/guybedford/es-module-lexer/actions/workflows/build.yml
|
||||
2
app_vue/node_modules/es-module-lexer/dist/lexer.asm.js
generated
vendored
Normal file
2
app_vue/node_modules/es-module-lexer/dist/lexer.asm.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
1
app_vue/node_modules/es-module-lexer/dist/lexer.cjs
generated
vendored
Normal file
1
app_vue/node_modules/es-module-lexer/dist/lexer.cjs
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
2
app_vue/node_modules/es-module-lexer/dist/lexer.js
generated
vendored
Normal file
2
app_vue/node_modules/es-module-lexer/dist/lexer.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
925
app_vue/node_modules/es-module-lexer/lexer.js
generated
vendored
Normal file
925
app_vue/node_modules/es-module-lexer/lexer.js
generated
vendored
Normal file
@ -0,0 +1,925 @@
|
||||
let source, pos, end,
|
||||
openTokenDepth,
|
||||
lastTokenPos,
|
||||
openTokenPosStack,
|
||||
openClassPosStack,
|
||||
curDynamicImport,
|
||||
templateStackDepth,
|
||||
facade,
|
||||
lastSlashWasDivision,
|
||||
nextBraceIsClass,
|
||||
templateDepth,
|
||||
templateStack,
|
||||
imports,
|
||||
exports,
|
||||
name;
|
||||
|
||||
function addImport (ss, s, e, d) {
|
||||
const impt = { ss, se: d === -2 ? e : d === -1 ? e + 1 : 0, s, e, d, a: -1, n: undefined };
|
||||
imports.push(impt);
|
||||
return impt;
|
||||
}
|
||||
|
||||
function addExport (s, e, ls, le) {
|
||||
exports.push({
|
||||
s,
|
||||
e,
|
||||
ls,
|
||||
le,
|
||||
n: s[0] === '"' ? readString(s, '"') : s[0] === "'" ? readString(s, "'") : source.slice(s, e),
|
||||
ln: ls[0] === '"' ? readString(ls, '"') : ls[0] === "'" ? readString(ls, "'") : source.slice(ls, le)
|
||||
});
|
||||
}
|
||||
|
||||
function readName (impt) {
|
||||
let { d, s } = impt;
|
||||
if (d !== -1)
|
||||
s++;
|
||||
impt.n = readString(s, source.charCodeAt(s - 1));
|
||||
}
|
||||
|
||||
// Note: parsing is based on the _assumption_ that the source is already valid
|
||||
export function parse (_source, _name) {
|
||||
openTokenDepth = 0;
|
||||
curDynamicImport = null;
|
||||
templateDepth = -1;
|
||||
lastTokenPos = -1;
|
||||
lastSlashWasDivision = false;
|
||||
templateStack = Array(1024);
|
||||
templateStackDepth = 0;
|
||||
openTokenPosStack = Array(1024);
|
||||
openClassPosStack = Array(1024);
|
||||
nextBraceIsClass = false;
|
||||
facade = true;
|
||||
name = _name || '@';
|
||||
|
||||
imports = [];
|
||||
exports = [];
|
||||
|
||||
source = _source;
|
||||
pos = -1;
|
||||
end = source.length - 1;
|
||||
let ch = 0;
|
||||
|
||||
// start with a pure "module-only" parser
|
||||
m: while (pos++ < end) {
|
||||
ch = source.charCodeAt(pos);
|
||||
|
||||
if (ch === 32 || ch < 14 && ch > 8)
|
||||
continue;
|
||||
|
||||
switch (ch) {
|
||||
case 101/*e*/:
|
||||
if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1)) {
|
||||
tryParseExportStatement();
|
||||
// export might have been a non-pure declaration
|
||||
if (!facade) {
|
||||
lastTokenPos = pos;
|
||||
break m;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 105/*i*/:
|
||||
if (keywordStart(pos) && source.startsWith('mport', pos + 1))
|
||||
tryParseImportStatement();
|
||||
break;
|
||||
case 59/*;*/:
|
||||
break;
|
||||
case 47/*/*/: {
|
||||
const next_ch = source.charCodeAt(pos + 1);
|
||||
if (next_ch === 47/*/*/) {
|
||||
lineComment();
|
||||
// dont update lastToken
|
||||
continue;
|
||||
}
|
||||
else if (next_ch === 42/***/) {
|
||||
blockComment(true);
|
||||
// dont update lastToken
|
||||
continue;
|
||||
}
|
||||
// fallthrough
|
||||
}
|
||||
default:
|
||||
// as soon as we hit a non-module token, we go to main parser
|
||||
facade = false;
|
||||
pos--;
|
||||
break m;
|
||||
}
|
||||
lastTokenPos = pos;
|
||||
}
|
||||
|
||||
while (pos++ < end) {
|
||||
ch = source.charCodeAt(pos);
|
||||
|
||||
if (ch === 32 || ch < 14 && ch > 8)
|
||||
continue;
|
||||
|
||||
switch (ch) {
|
||||
case 101/*e*/:
|
||||
if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1))
|
||||
tryParseExportStatement();
|
||||
break;
|
||||
case 105/*i*/:
|
||||
if (keywordStart(pos) && source.startsWith('mport', pos + 1))
|
||||
tryParseImportStatement();
|
||||
break;
|
||||
case 99/*c*/:
|
||||
if (keywordStart(pos) && source.startsWith('lass', pos + 1) && isBrOrWs(source.charCodeAt(pos + 5)))
|
||||
nextBraceIsClass = true;
|
||||
break;
|
||||
case 40/*(*/:
|
||||
openTokenPosStack[openTokenDepth++] = lastTokenPos;
|
||||
break;
|
||||
case 41/*)*/:
|
||||
if (openTokenDepth === 0)
|
||||
syntaxError();
|
||||
openTokenDepth--;
|
||||
if (curDynamicImport && curDynamicImport.d === openTokenPosStack[openTokenDepth]) {
|
||||
if (curDynamicImport.e === 0)
|
||||
curDynamicImport.e = pos;
|
||||
curDynamicImport.se = pos;
|
||||
curDynamicImport = null;
|
||||
}
|
||||
break;
|
||||
case 123/*{*/:
|
||||
// dynamic import followed by { is not a dynamic import (so remove)
|
||||
// this is a sneaky way to get around { import () {} } v { import () }
|
||||
// block / object ambiguity without a parser (assuming source is valid)
|
||||
if (source.charCodeAt(lastTokenPos) === 41/*)*/ && imports.length && imports[imports.length - 1].e === lastTokenPos) {
|
||||
imports.pop();
|
||||
}
|
||||
openClassPosStack[openTokenDepth] = nextBraceIsClass;
|
||||
nextBraceIsClass = false;
|
||||
openTokenPosStack[openTokenDepth++] = lastTokenPos;
|
||||
break;
|
||||
case 125/*}*/:
|
||||
if (openTokenDepth === 0)
|
||||
syntaxError();
|
||||
if (openTokenDepth-- === templateDepth) {
|
||||
templateDepth = templateStack[--templateStackDepth];
|
||||
templateString();
|
||||
}
|
||||
else {
|
||||
if (templateDepth !== -1 && openTokenDepth < templateDepth)
|
||||
syntaxError();
|
||||
}
|
||||
break;
|
||||
case 39/*'*/:
|
||||
case 34/*"*/:
|
||||
stringLiteral(ch);
|
||||
break;
|
||||
case 47/*/*/: {
|
||||
const next_ch = source.charCodeAt(pos + 1);
|
||||
if (next_ch === 47/*/*/) {
|
||||
lineComment();
|
||||
// dont update lastToken
|
||||
continue;
|
||||
}
|
||||
else if (next_ch === 42/***/) {
|
||||
blockComment(true);
|
||||
// dont update lastToken
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
// Division / regex ambiguity handling based on checking backtrack analysis of:
|
||||
// - what token came previously (lastToken)
|
||||
// - if a closing brace or paren, what token came before the corresponding
|
||||
// opening brace or paren (lastOpenTokenIndex)
|
||||
const lastToken = source.charCodeAt(lastTokenPos);
|
||||
const lastExport = exports[exports.length - 1];
|
||||
if (isExpressionPunctuator(lastToken) &&
|
||||
!(lastToken === 46/*.*/ && (source.charCodeAt(lastTokenPos - 1) >= 48/*0*/ && source.charCodeAt(lastTokenPos - 1) <= 57/*9*/)) &&
|
||||
!(lastToken === 43/*+*/ && source.charCodeAt(lastTokenPos - 1) === 43/*+*/) && !(lastToken === 45/*-*/ && source.charCodeAt(lastTokenPos - 1) === 45/*-*/) ||
|
||||
lastToken === 41/*)*/ && isParenKeyword(openTokenPosStack[openTokenDepth]) ||
|
||||
lastToken === 125/*}*/ && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) ||
|
||||
lastToken === 47/*/*/ && lastSlashWasDivision ||
|
||||
isExpressionKeyword(lastTokenPos) ||
|
||||
!lastToken) {
|
||||
regularExpression();
|
||||
lastSlashWasDivision = false;
|
||||
}
|
||||
else if (lastExport && lastTokenPos >= lastExport.s && lastTokenPos <= lastExport.e) {
|
||||
// export default /some-regexp/
|
||||
regularExpression();
|
||||
lastSlashWasDivision = false;
|
||||
}
|
||||
else {
|
||||
lastSlashWasDivision = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 96/*`*/:
|
||||
templateString();
|
||||
break;
|
||||
}
|
||||
lastTokenPos = pos;
|
||||
}
|
||||
|
||||
if (templateDepth !== -1 || openTokenDepth)
|
||||
syntaxError();
|
||||
|
||||
return [imports, exports, facade];
|
||||
}
|
||||
|
||||
function tryParseImportStatement () {
|
||||
const startPos = pos;
|
||||
|
||||
pos += 6;
|
||||
|
||||
let ch = commentWhitespace(true);
|
||||
|
||||
switch (ch) {
|
||||
// dynamic import
|
||||
case 40/*(*/:
|
||||
openTokenPosStack[openTokenDepth++] = startPos;
|
||||
if (source.charCodeAt(lastTokenPos) === 46/*.*/)
|
||||
return;
|
||||
// dynamic import indicated by positive d
|
||||
const impt = addImport(startPos, pos + 1, 0, startPos);
|
||||
curDynamicImport = impt;
|
||||
// try parse a string, to record a safe dynamic import string
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 39/*'*/ || ch === 34/*"*/) {
|
||||
stringLiteral(ch);
|
||||
}
|
||||
else {
|
||||
pos--;
|
||||
return;
|
||||
}
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 44/*,*/) {
|
||||
impt.e = pos;
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
impt.a = pos;
|
||||
readName(impt);
|
||||
pos--;
|
||||
}
|
||||
else if (ch === 41/*)*/) {
|
||||
openTokenDepth--;
|
||||
impt.e = pos;
|
||||
impt.se = pos;
|
||||
readName(impt);
|
||||
}
|
||||
else {
|
||||
pos--;
|
||||
}
|
||||
return;
|
||||
// import.meta
|
||||
case 46/*.*/:
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
// import.meta indicated by d === -2
|
||||
if (ch === 109/*m*/ && source.startsWith('eta', pos + 1) && source.charCodeAt(lastTokenPos) !== 46/*.*/)
|
||||
addImport(startPos, startPos, pos + 4, -2);
|
||||
return;
|
||||
|
||||
default:
|
||||
// no space after "import" -> not an import keyword
|
||||
if (pos === startPos + 6)
|
||||
break;
|
||||
case 34/*"*/:
|
||||
case 39/*'*/:
|
||||
case 123/*{*/:
|
||||
case 42/***/:
|
||||
// import statement only permitted at base-level
|
||||
if (openTokenDepth !== 0) {
|
||||
pos--;
|
||||
return;
|
||||
}
|
||||
while (pos < end) {
|
||||
ch = source.charCodeAt(pos);
|
||||
if (ch === 39/*'*/ || ch === 34/*"*/) {
|
||||
readImportString(startPos, ch);
|
||||
return;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
syntaxError();
|
||||
}
|
||||
}
|
||||
|
||||
function tryParseExportStatement () {
|
||||
const sStartPos = pos;
|
||||
const prevExport = exports.length;
|
||||
|
||||
pos += 6;
|
||||
|
||||
const curPos = pos;
|
||||
|
||||
let ch = commentWhitespace(true);
|
||||
|
||||
if (pos === curPos && !isPunctuator(ch))
|
||||
return;
|
||||
|
||||
switch (ch) {
|
||||
// export default ...
|
||||
case 100/*d*/:
|
||||
addExport(pos, pos + 7, -1, -1);
|
||||
return;
|
||||
|
||||
// export async? function*? name () {
|
||||
case 97/*a*/:
|
||||
pos += 5;
|
||||
commentWhitespace(true);
|
||||
// fallthrough
|
||||
case 102/*f*/:
|
||||
pos += 8;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 42/***/) {
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
}
|
||||
const startPos = pos;
|
||||
ch = readToWsOrPunctuator(ch);
|
||||
addExport(startPos, pos, startPos, pos);
|
||||
pos--;
|
||||
return;
|
||||
|
||||
// export class name ...
|
||||
case 99/*c*/:
|
||||
if (source.startsWith('lass', pos + 1) && isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos + 5))) {
|
||||
pos += 5;
|
||||
ch = commentWhitespace(true);
|
||||
const startPos = pos;
|
||||
ch = readToWsOrPunctuator(ch);
|
||||
addExport(startPos, pos, startPos, pos);
|
||||
pos--;
|
||||
return;
|
||||
}
|
||||
pos += 2;
|
||||
// fallthrough
|
||||
|
||||
// export var/let/const name = ...(, name = ...)+
|
||||
case 118/*v*/:
|
||||
case 109/*l*/:
|
||||
// destructured initializations not currently supported (skipped for { or [)
|
||||
// also, lexing names after variable equals is skipped (export var p = function () { ... }, q = 5 skips "q")
|
||||
pos += 2;
|
||||
facade = false;
|
||||
do {
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
const startPos = pos;
|
||||
ch = readToWsOrPunctuator(ch);
|
||||
// dont yet handle [ { destructurings
|
||||
if (ch === 123/*{*/ || ch === 91/*[*/) {
|
||||
pos--;
|
||||
return;
|
||||
}
|
||||
if (pos === startPos)
|
||||
return;
|
||||
addExport(startPos, pos, startPos, pos);
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 61/*=*/) {
|
||||
pos--;
|
||||
return;
|
||||
}
|
||||
} while (ch === 44/*,*/);
|
||||
pos--;
|
||||
return;
|
||||
|
||||
|
||||
// export {...}
|
||||
case 123/*{*/:
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
while (true) {
|
||||
const startPos = pos;
|
||||
readToWsOrPunctuator(ch);
|
||||
const endPos = pos;
|
||||
commentWhitespace(true);
|
||||
ch = readExportAs(startPos, endPos);
|
||||
// ,
|
||||
if (ch === 44/*,*/) {
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
}
|
||||
if (ch === 125/*}*/)
|
||||
break;
|
||||
if (pos === startPos)
|
||||
return syntaxError();
|
||||
if (pos > end)
|
||||
return syntaxError();
|
||||
}
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
break;
|
||||
|
||||
// export *
|
||||
// export * as X
|
||||
case 42/***/:
|
||||
pos++;
|
||||
commentWhitespace(true);
|
||||
ch = readExportAs(pos, pos);
|
||||
ch = commentWhitespace(true);
|
||||
break;
|
||||
}
|
||||
|
||||
// from ...
|
||||
if (ch === 102/*f*/ && source.startsWith('rom', pos + 1)) {
|
||||
pos += 4;
|
||||
readImportString(sStartPos, commentWhitespace(true));
|
||||
|
||||
// There were no local names.
|
||||
for (let i = prevExport; i < exports.length; ++i) {
|
||||
exports[i].ls = exports[i].le = -1;
|
||||
exports[i].ln = undefined;
|
||||
}
|
||||
}
|
||||
else {
|
||||
pos--;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Ported from Acorn
|
||||
*
|
||||
* MIT License
|
||||
|
||||
* Copyright (C) 2012-2020 by various contributors (see AUTHORS)
|
||||
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
let acornPos;
|
||||
function readString (start, quote) {
|
||||
acornPos = start;
|
||||
let out = '', chunkStart = acornPos;
|
||||
for (;;) {
|
||||
if (acornPos >= source.length) syntaxError();
|
||||
const ch = source.charCodeAt(acornPos);
|
||||
if (ch === quote) break;
|
||||
if (ch === 92) { // '\'
|
||||
out += source.slice(chunkStart, acornPos);
|
||||
out += readEscapedChar();
|
||||
chunkStart = acornPos;
|
||||
}
|
||||
else if (ch === 0x2028 || ch === 0x2029) {
|
||||
++acornPos;
|
||||
}
|
||||
else {
|
||||
if (isBr(ch)) syntaxError();
|
||||
++acornPos;
|
||||
}
|
||||
}
|
||||
out += source.slice(chunkStart, acornPos++);
|
||||
return out;
|
||||
}
|
||||
|
||||
// Used to read escaped characters
|
||||
|
||||
function readEscapedChar () {
|
||||
let ch = source.charCodeAt(++acornPos);
|
||||
++acornPos;
|
||||
switch (ch) {
|
||||
case 110: return '\n'; // 'n' -> '\n'
|
||||
case 114: return '\r'; // 'r' -> '\r'
|
||||
case 120: return String.fromCharCode(readHexChar(2)); // 'x'
|
||||
case 117: return readCodePointToString(); // 'u'
|
||||
case 116: return '\t'; // 't' -> '\t'
|
||||
case 98: return '\b'; // 'b' -> '\b'
|
||||
case 118: return '\u000b'; // 'v' -> '\u000b'
|
||||
case 102: return '\f'; // 'f' -> '\f'
|
||||
case 13: if (source.charCodeAt(acornPos) === 10) ++acornPos; // '\r\n'
|
||||
case 10: // ' \n'
|
||||
return '';
|
||||
case 56:
|
||||
case 57:
|
||||
syntaxError();
|
||||
default:
|
||||
if (ch >= 48 && ch <= 55) {
|
||||
let octalStr = source.substr(acornPos - 1, 3).match(/^[0-7]+/)[0];
|
||||
let octal = parseInt(octalStr, 8);
|
||||
if (octal > 255) {
|
||||
octalStr = octalStr.slice(0, -1);
|
||||
octal = parseInt(octalStr, 8);
|
||||
}
|
||||
acornPos += octalStr.length - 1;
|
||||
ch = source.charCodeAt(acornPos);
|
||||
if (octalStr !== '0' || ch === 56 || ch === 57)
|
||||
syntaxError();
|
||||
return String.fromCharCode(octal);
|
||||
}
|
||||
if (isBr(ch)) {
|
||||
// Unicode new line characters after \ get removed from output in both
|
||||
// template literals and strings
|
||||
return '';
|
||||
}
|
||||
return String.fromCharCode(ch);
|
||||
}
|
||||
}
|
||||
|
||||
// Used to read character escape sequences ('\x', '\u', '\U').
|
||||
|
||||
function readHexChar (len) {
|
||||
const start = acornPos;
|
||||
let total = 0, lastCode = 0;
|
||||
for (let i = 0; i < len; ++i, ++acornPos) {
|
||||
let code = source.charCodeAt(acornPos), val;
|
||||
|
||||
if (code === 95) {
|
||||
if (lastCode === 95 || i === 0) syntaxError();
|
||||
lastCode = code;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (code >= 97) val = code - 97 + 10; // a
|
||||
else if (code >= 65) val = code - 65 + 10; // A
|
||||
else if (code >= 48 && code <= 57) val = code - 48; // 0-9
|
||||
else break;
|
||||
if (val >= 16) break;
|
||||
lastCode = code;
|
||||
total = total * 16 + val;
|
||||
}
|
||||
|
||||
if (lastCode === 95 || acornPos - start !== len) syntaxError();
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
// Read a string value, interpreting backslash-escapes.
|
||||
|
||||
function readCodePointToString () {
|
||||
const ch = source.charCodeAt(acornPos);
|
||||
let code;
|
||||
if (ch === 123) { // '{'
|
||||
++acornPos;
|
||||
code = readHexChar(source.indexOf('}', acornPos) - acornPos);
|
||||
++acornPos;
|
||||
if (code > 0x10FFFF) syntaxError();
|
||||
} else {
|
||||
code = readHexChar(4);
|
||||
}
|
||||
// UTF-16 Decoding
|
||||
if (code <= 0xFFFF) return String.fromCharCode(code);
|
||||
code -= 0x10000;
|
||||
return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00);
|
||||
}
|
||||
|
||||
/*
|
||||
* </ Acorn Port>
|
||||
*/
|
||||
|
||||
function readExportAs (startPos, endPos) {
|
||||
let ch = source.charCodeAt(pos);
|
||||
let ls = startPos, le = endPos;
|
||||
if (ch === 97 /*a*/) {
|
||||
pos += 2;
|
||||
ch = commentWhitespace(true);
|
||||
startPos = pos;
|
||||
readToWsOrPunctuator(ch);
|
||||
endPos = pos;
|
||||
ch = commentWhitespace(true);
|
||||
}
|
||||
if (pos !== startPos)
|
||||
addExport(startPos, endPos, ls, le);
|
||||
return ch;
|
||||
}
|
||||
|
||||
function readImportString (ss, ch) {
|
||||
const startPos = pos + 1;
|
||||
if (ch === 39/*'*/ || ch === 34/*"*/) {
|
||||
stringLiteral(ch);
|
||||
}
|
||||
else {
|
||||
syntaxError();
|
||||
return;
|
||||
}
|
||||
const impt = addImport(ss, startPos, pos, -1);
|
||||
readName(impt);
|
||||
pos++;
|
||||
ch = commentWhitespace(false);
|
||||
if (ch !== 97/*a*/ || !source.startsWith('ssert', pos + 1)) {
|
||||
pos--;
|
||||
return;
|
||||
}
|
||||
const assertIndex = pos;
|
||||
|
||||
pos += 6;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch !== 123/*{*/) {
|
||||
pos = assertIndex;
|
||||
return;
|
||||
}
|
||||
const assertStart = pos;
|
||||
do {
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 39/*'*/ || ch === 34/*"*/) {
|
||||
stringLiteral(ch);
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
}
|
||||
else {
|
||||
ch = readToWsOrPunctuator(ch);
|
||||
}
|
||||
if (ch !== 58/*:*/) {
|
||||
pos = assertIndex;
|
||||
return;
|
||||
}
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 39/*'*/ || ch === 34/*"*/) {
|
||||
stringLiteral(ch);
|
||||
}
|
||||
else {
|
||||
pos = assertIndex;
|
||||
return;
|
||||
}
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 44/*,*/) {
|
||||
pos++;
|
||||
ch = commentWhitespace(true);
|
||||
if (ch === 125/*}*/)
|
||||
break;
|
||||
continue;
|
||||
}
|
||||
if (ch === 125/*}*/)
|
||||
break;
|
||||
pos = assertIndex;
|
||||
return;
|
||||
} while (true);
|
||||
impt.a = assertStart;
|
||||
impt.se = pos + 1;
|
||||
}
|
||||
|
||||
function commentWhitespace (br) {
|
||||
let ch;
|
||||
do {
|
||||
ch = source.charCodeAt(pos);
|
||||
if (ch === 47/*/*/) {
|
||||
const next_ch = source.charCodeAt(pos + 1);
|
||||
if (next_ch === 47/*/*/)
|
||||
lineComment();
|
||||
else if (next_ch === 42/***/)
|
||||
blockComment(br);
|
||||
else
|
||||
return ch;
|
||||
}
|
||||
else if (br ? !isBrOrWs(ch): !isWsNotBr(ch)) {
|
||||
return ch;
|
||||
}
|
||||
} while (pos++ < end);
|
||||
return ch;
|
||||
}
|
||||
|
||||
function templateString () {
|
||||
while (pos++ < end) {
|
||||
const ch = source.charCodeAt(pos);
|
||||
if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/) {
|
||||
pos++;
|
||||
templateStack[templateStackDepth++] = templateDepth;
|
||||
templateDepth = ++openTokenDepth;
|
||||
return;
|
||||
}
|
||||
if (ch === 96/*`*/)
|
||||
return;
|
||||
if (ch === 92/*\*/)
|
||||
pos++;
|
||||
}
|
||||
syntaxError();
|
||||
}
|
||||
|
||||
function blockComment (br) {
|
||||
pos++;
|
||||
while (pos++ < end) {
|
||||
const ch = source.charCodeAt(pos);
|
||||
if (!br && isBr(ch))
|
||||
return;
|
||||
if (ch === 42/***/ && source.charCodeAt(pos + 1) === 47/*/*/) {
|
||||
pos++;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function lineComment () {
|
||||
while (pos++ < end) {
|
||||
const ch = source.charCodeAt(pos);
|
||||
if (ch === 10/*\n*/ || ch === 13/*\r*/)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
function stringLiteral (quote) {
|
||||
while (pos++ < end) {
|
||||
let ch = source.charCodeAt(pos);
|
||||
if (ch === quote)
|
||||
return;
|
||||
if (ch === 92/*\*/) {
|
||||
ch = source.charCodeAt(++pos);
|
||||
if (ch === 13/*\r*/ && source.charCodeAt(pos + 1) === 10/*\n*/)
|
||||
pos++;
|
||||
}
|
||||
else if (isBr(ch))
|
||||
break;
|
||||
}
|
||||
syntaxError();
|
||||
}
|
||||
|
||||
function regexCharacterClass () {
|
||||
while (pos++ < end) {
|
||||
let ch = source.charCodeAt(pos);
|
||||
if (ch === 93/*]*/)
|
||||
return ch;
|
||||
if (ch === 92/*\*/)
|
||||
pos++;
|
||||
else if (ch === 10/*\n*/ || ch === 13/*\r*/)
|
||||
break;
|
||||
}
|
||||
syntaxError();
|
||||
}
|
||||
|
||||
function regularExpression () {
|
||||
while (pos++ < end) {
|
||||
let ch = source.charCodeAt(pos);
|
||||
if (ch === 47/*/*/)
|
||||
return;
|
||||
if (ch === 91/*[*/)
|
||||
ch = regexCharacterClass();
|
||||
else if (ch === 92/*\*/)
|
||||
pos++;
|
||||
else if (ch === 10/*\n*/ || ch === 13/*\r*/)
|
||||
break;
|
||||
}
|
||||
syntaxError();
|
||||
}
|
||||
|
||||
function readToWsOrPunctuator (ch) {
|
||||
do {
|
||||
if (isBrOrWs(ch) || isPunctuator(ch))
|
||||
return ch;
|
||||
} while (ch = source.charCodeAt(++pos));
|
||||
return ch;
|
||||
}
|
||||
|
||||
// Note: non-asii BR and whitespace checks omitted for perf / footprint
|
||||
// if there is a significant user need this can be reconsidered
|
||||
function isBr (c) {
|
||||
return c === 13/*\r*/ || c === 10/*\n*/;
|
||||
}
|
||||
|
||||
function isWsNotBr (c) {
|
||||
return c === 9 || c === 11 || c === 12 || c === 32 || c === 160;
|
||||
}
|
||||
|
||||
function isBrOrWs (c) {
|
||||
return c > 8 && c < 14 || c === 32 || c === 160;
|
||||
}
|
||||
|
||||
function isBrOrWsOrPunctuatorNotDot (c) {
|
||||
return c > 8 && c < 14 || c === 32 || c === 160 || isPunctuator(c) && c !== 46/*.*/;
|
||||
}
|
||||
|
||||
function keywordStart (pos) {
|
||||
return pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1));
|
||||
}
|
||||
|
||||
function readPrecedingKeyword (pos, match) {
|
||||
if (pos < match.length - 1)
|
||||
return false;
|
||||
return source.startsWith(match, pos - match.length + 1) && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - match.length)));
|
||||
}
|
||||
|
||||
function readPrecedingKeyword1 (pos, ch) {
|
||||
return source.charCodeAt(pos) === ch && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1)));
|
||||
}
|
||||
|
||||
// Detects one of case, debugger, delete, do, else, in, instanceof, new,
|
||||
// return, throw, typeof, void, yield, await
|
||||
function isExpressionKeyword (pos) {
|
||||
switch (source.charCodeAt(pos)) {
|
||||
case 100/*d*/:
|
||||
switch (source.charCodeAt(pos - 1)) {
|
||||
case 105/*i*/:
|
||||
// void
|
||||
return readPrecedingKeyword(pos - 2, 'vo');
|
||||
case 108/*l*/:
|
||||
// yield
|
||||
return readPrecedingKeyword(pos - 2, 'yie');
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case 101/*e*/:
|
||||
switch (source.charCodeAt(pos - 1)) {
|
||||
case 115/*s*/:
|
||||
switch (source.charCodeAt(pos - 2)) {
|
||||
case 108/*l*/:
|
||||
// else
|
||||
return readPrecedingKeyword1(pos - 3, 101/*e*/);
|
||||
case 97/*a*/:
|
||||
// case
|
||||
return readPrecedingKeyword1(pos - 3, 99/*c*/);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case 116/*t*/:
|
||||
// delete
|
||||
return readPrecedingKeyword(pos - 2, 'dele');
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case 102/*f*/:
|
||||
if (source.charCodeAt(pos - 1) !== 111/*o*/ || source.charCodeAt(pos - 2) !== 101/*e*/)
|
||||
return false;
|
||||
switch (source.charCodeAt(pos - 3)) {
|
||||
case 99/*c*/:
|
||||
// instanceof
|
||||
return readPrecedingKeyword(pos - 4, 'instan');
|
||||
case 112/*p*/:
|
||||
// typeof
|
||||
return readPrecedingKeyword(pos - 4, 'ty');
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case 110/*n*/:
|
||||
// in, return
|
||||
return readPrecedingKeyword1(pos - 1, 105/*i*/) || readPrecedingKeyword(pos - 1, 'retur');
|
||||
case 111/*o*/:
|
||||
// do
|
||||
return readPrecedingKeyword1(pos - 1, 100/*d*/);
|
||||
case 114/*r*/:
|
||||
// debugger
|
||||
return readPrecedingKeyword(pos - 1, 'debugge');
|
||||
case 116/*t*/:
|
||||
// await
|
||||
return readPrecedingKeyword(pos - 1, 'awai');
|
||||
case 119/*w*/:
|
||||
switch (source.charCodeAt(pos - 1)) {
|
||||
case 101/*e*/:
|
||||
// new
|
||||
return readPrecedingKeyword1(pos - 2, 110/*n*/);
|
||||
case 111/*o*/:
|
||||
// throw
|
||||
return readPrecedingKeyword(pos - 2, 'thr');
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function isParenKeyword (curPos) {
|
||||
return source.charCodeAt(curPos) === 101/*e*/ && source.startsWith('whil', curPos - 4) ||
|
||||
source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2) ||
|
||||
source.charCodeAt(curPos - 1) === 105/*i*/ && source.charCodeAt(curPos) === 102/*f*/;
|
||||
}
|
||||
|
||||
function isPunctuator (ch) {
|
||||
// 23 possible punctuator endings: !%&()*+,-./:;<=>?[]^{}|~
|
||||
return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||
|
||||
ch > 39 && ch < 48 || ch > 57 && ch < 64 ||
|
||||
ch === 91/*[*/ || ch === 93/*]*/ || ch === 94/*^*/ ||
|
||||
ch > 122 && ch < 127;
|
||||
}
|
||||
|
||||
function isExpressionPunctuator (ch) {
|
||||
// 20 possible expression endings: !%&(*+,-.:;<=>?[^{|~
|
||||
return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||
|
||||
ch > 39 && ch < 47 && ch !== 41 || ch > 57 && ch < 64 ||
|
||||
ch === 91/*[*/ || ch === 94/*^*/ || ch > 122 && ch < 127 && ch !== 125/*}*/;
|
||||
}
|
||||
|
||||
function isExpressionTerminator (curPos) {
|
||||
// detects:
|
||||
// => ; ) finally catch else
|
||||
// as all of these followed by a { will indicate a statement brace
|
||||
switch (source.charCodeAt(curPos)) {
|
||||
case 62/*>*/:
|
||||
return source.charCodeAt(curPos - 1) === 61/*=*/;
|
||||
case 59/*;*/:
|
||||
case 41/*)*/:
|
||||
return true;
|
||||
case 104/*h*/:
|
||||
return source.startsWith('catc', curPos - 4);
|
||||
case 121/*y*/:
|
||||
return source.startsWith('finall', curPos - 6);
|
||||
case 101/*e*/:
|
||||
return source.startsWith('els', curPos - 3);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function syntaxError () {
|
||||
throw Object.assign(new Error(`Parse error ${name}:${source.slice(0, pos).split('\n').length}:${pos - source.lastIndexOf('\n', pos - 1)}`), { idx: pos });
|
||||
}
|
||||
57
app_vue/node_modules/es-module-lexer/package.json
generated
vendored
Normal file
57
app_vue/node_modules/es-module-lexer/package.json
generated
vendored
Normal file
@ -0,0 +1,57 @@
|
||||
{
|
||||
"name": "es-module-lexer",
|
||||
"version": "1.7.0",
|
||||
"description": "Lexes ES modules returning their import/export metadata",
|
||||
"main": "dist/lexer.cjs",
|
||||
"module": "dist/lexer.js",
|
||||
"types": "types/lexer.d.ts",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./types/lexer.d.ts",
|
||||
"module": "./dist/lexer.js",
|
||||
"import": "./dist/lexer.js",
|
||||
"require": "./dist/lexer.cjs"
|
||||
},
|
||||
"./js": {
|
||||
"types": "./types/lexer.d.ts",
|
||||
"default": "./dist/lexer.asm.js"
|
||||
}
|
||||
},
|
||||
"scripts": {
|
||||
"build": "npm install -g chomp ; chomp build",
|
||||
"test": "npm install -g chomp ; chomp test"
|
||||
},
|
||||
"author": "Guy Bedford",
|
||||
"license": "MIT",
|
||||
"devDependencies": {
|
||||
"@babel/cli": "^7.5.5",
|
||||
"@babel/core": "^7.5.5",
|
||||
"@babel/plugin-transform-modules-commonjs": "^7.5.0",
|
||||
"@swc/cli": "^0.1.57",
|
||||
"@swc/core": "^1.2.224",
|
||||
"@types/node": "^18.7.1",
|
||||
"kleur": "^2.0.2",
|
||||
"mocha": "^5.2.0",
|
||||
"terser": "^5.19.4",
|
||||
"typescript": "^4.7.4"
|
||||
},
|
||||
"files": [
|
||||
"dist",
|
||||
"types",
|
||||
"lexer.js"
|
||||
],
|
||||
"type": "module",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/guybedford/es-module-lexer.git"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/guybedford/es-module-lexer/issues"
|
||||
},
|
||||
"homepage": "https://github.com/guybedford/es-module-lexer#readme",
|
||||
"directories": {
|
||||
"lib": "lib",
|
||||
"test": "test"
|
||||
},
|
||||
"keywords": []
|
||||
}
|
||||
195
app_vue/node_modules/es-module-lexer/types/lexer.d.ts
generated
vendored
Normal file
195
app_vue/node_modules/es-module-lexer/types/lexer.d.ts
generated
vendored
Normal file
@ -0,0 +1,195 @@
|
||||
export declare enum ImportType {
|
||||
/**
|
||||
* A normal static using any syntax variations
|
||||
* import .. from 'module'
|
||||
*/
|
||||
Static = 1,
|
||||
/**
|
||||
* A dynamic import expression `import(specifier)`
|
||||
* or `import(specifier, opts)`
|
||||
*/
|
||||
Dynamic = 2,
|
||||
/**
|
||||
* An import.meta expression
|
||||
*/
|
||||
ImportMeta = 3,
|
||||
/**
|
||||
* A source phase import
|
||||
* import source x from 'module'
|
||||
*/
|
||||
StaticSourcePhase = 4,
|
||||
/**
|
||||
* A dynamic source phase import
|
||||
* import.source('module')
|
||||
*/
|
||||
DynamicSourcePhase = 5,
|
||||
/**
|
||||
* A defer phase import
|
||||
* import defer * as x from 'module'
|
||||
*/
|
||||
StaticDeferPhase = 6,
|
||||
/**
|
||||
* A dynamic defer phase import
|
||||
* import.defer('module')
|
||||
*/
|
||||
DynamicDeferPhase = 7
|
||||
}
|
||||
export interface ImportSpecifier {
|
||||
/**
|
||||
* Module name
|
||||
*
|
||||
* To handle escape sequences in specifier strings, the .n field of imported specifiers will be provided where possible.
|
||||
*
|
||||
* For dynamic import expressions, this field will be empty if not a valid JS string.
|
||||
* For static import expressions, this field will always be populated.
|
||||
*
|
||||
* @example
|
||||
* const [imports1, exports1] = parse(String.raw`import './\u0061\u0062.js'`);
|
||||
* imports1[0].n;
|
||||
* // Returns "./ab.js"
|
||||
*
|
||||
* const [imports2, exports2] = parse(`import("./ab.js")`);
|
||||
* imports2[0].n;
|
||||
* // Returns "./ab.js"
|
||||
*
|
||||
* const [imports3, exports3] = parse(`import("./" + "ab.js")`);
|
||||
* imports3[0].n;
|
||||
* // Returns undefined
|
||||
*/
|
||||
readonly n: string | undefined;
|
||||
/**
|
||||
* Type of import statement
|
||||
*/
|
||||
readonly t: ImportType;
|
||||
/**
|
||||
* Start of module specifier
|
||||
*
|
||||
* @example
|
||||
* const source = `import { a } from 'asdf'`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* source.substring(imports[0].s, imports[0].e);
|
||||
* // Returns "asdf"
|
||||
*/
|
||||
readonly s: number;
|
||||
/**
|
||||
* End of module specifier
|
||||
*/
|
||||
readonly e: number;
|
||||
/**
|
||||
* Start of import statement
|
||||
*
|
||||
* @example
|
||||
* const source = `import { a } from 'asdf'`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* source.substring(imports[0].ss, imports[0].se);
|
||||
* // Returns "import { a } from 'asdf';"
|
||||
*/
|
||||
readonly ss: number;
|
||||
/**
|
||||
* End of import statement
|
||||
*/
|
||||
readonly se: number;
|
||||
/**
|
||||
* If this import keyword is a dynamic import, this is the start value.
|
||||
* If this import keyword is a static import, this is -1.
|
||||
* If this import keyword is an import.meta expresion, this is -2.
|
||||
*/
|
||||
readonly d: number;
|
||||
/**
|
||||
* If this import has an import assertion, this is the start value.
|
||||
* Otherwise this is `-1`.
|
||||
*/
|
||||
readonly a: number;
|
||||
}
|
||||
export interface ExportSpecifier {
|
||||
/**
|
||||
* Exported name
|
||||
*
|
||||
* @example
|
||||
* const source = `export default []`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* exports[0].n;
|
||||
* // Returns "default"
|
||||
*
|
||||
* @example
|
||||
* const source = `export const asdf = 42`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* exports[0].n;
|
||||
* // Returns "asdf"
|
||||
*/
|
||||
readonly n: string;
|
||||
/**
|
||||
* Local name, or undefined.
|
||||
*
|
||||
* @example
|
||||
* const source = `export default []`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* exports[0].ln;
|
||||
* // Returns undefined
|
||||
*
|
||||
* @example
|
||||
* const asdf = 42;
|
||||
* const source = `export { asdf as a }`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* exports[0].ln;
|
||||
* // Returns "asdf"
|
||||
*/
|
||||
readonly ln: string | undefined;
|
||||
/**
|
||||
* Start of exported name
|
||||
*
|
||||
* @example
|
||||
* const source = `export default []`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* source.substring(exports[0].s, exports[0].e);
|
||||
* // Returns "default"
|
||||
*
|
||||
* @example
|
||||
* const source = `export { 42 as asdf }`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* source.substring(exports[0].s, exports[0].e);
|
||||
* // Returns "asdf"
|
||||
*/
|
||||
readonly s: number;
|
||||
/**
|
||||
* End of exported name
|
||||
*/
|
||||
readonly e: number;
|
||||
/**
|
||||
* Start of local name, or -1.
|
||||
*
|
||||
* @example
|
||||
* const asdf = 42;
|
||||
* const source = `export { asdf as a }`;
|
||||
* const [imports, exports] = parse(source);
|
||||
* source.substring(exports[0].ls, exports[0].le);
|
||||
* // Returns "asdf"
|
||||
*/
|
||||
readonly ls: number;
|
||||
/**
|
||||
* End of local name, or -1.
|
||||
*/
|
||||
readonly le: number;
|
||||
}
|
||||
export interface ParseError extends Error {
|
||||
idx: number;
|
||||
}
|
||||
/**
|
||||
* Outputs the list of exports and locations of import specifiers,
|
||||
* including dynamic import and import meta handling.
|
||||
*
|
||||
* @param source Source code to parser
|
||||
* @param name Optional sourcename
|
||||
* @returns Tuple contaning imports list and exports list.
|
||||
*/
|
||||
export declare function parse(source: string, name?: string): readonly [
|
||||
imports: ReadonlyArray<ImportSpecifier>,
|
||||
exports: ReadonlyArray<ExportSpecifier>,
|
||||
facade: boolean,
|
||||
hasModuleSyntax: boolean
|
||||
];
|
||||
/**
|
||||
* Wait for init to resolve before calling `parse`.
|
||||
*/
|
||||
export declare const init: Promise<void>;
|
||||
export declare const initSync: () => void;
|
||||
Reference in New Issue
Block a user