vaderjs 1.1.1 → 1.1.2

package/website/node_modules/source-map-js/source-map.d.ts

@@ -0,0 +1,115 @@
+declare module 'source-map-js' { 
+    export interface StartOfSourceMap {
+        file?: string;
+        sourceRoot?: string;
+    }
+
+    export interface RawSourceMap extends StartOfSourceMap {
+        version: string;
+        sources: string[];
+        names: string[];
+        sourcesContent?: string[];
+        mappings: string;
+    }
+
+    export interface Position {
+        line: number;
+        column: number;
+    }
+
+    export interface LineRange extends Position {
+        lastColumn: number;
+    }
+
+    export interface FindPosition extends Position {
+        // SourceMapConsumer.GREATEST_LOWER_BOUND or SourceMapConsumer.LEAST_UPPER_BOUND
+        bias?: number;
+    }
+
+    export interface SourceFindPosition extends FindPosition {
+        source: string;
+    }
+
+    export interface MappedPosition extends Position {
+        source: string;
+        name?: string;
+    }
+
+    export interface MappingItem {
+        source: string;
+        generatedLine: number;
+        generatedColumn: number;
+        originalLine: number;
+        originalColumn: number;
+        name: string;
+    }
+
+    export class SourceMapConsumer {
+        static GENERATED_ORDER: number;
+        static ORIGINAL_ORDER: number;
+
+        static GREATEST_LOWER_BOUND: number;
+        static LEAST_UPPER_BOUND: number;
+
+        constructor(rawSourceMap: RawSourceMap);
+        computeColumnSpans(): void;
+        originalPositionFor(generatedPosition: FindPosition): MappedPosition;
+        generatedPositionFor(originalPosition: SourceFindPosition): LineRange;
+        allGeneratedPositionsFor(originalPosition: MappedPosition): Position[];
+        hasContentsOfAllSources(): boolean;
+        sourceContentFor(source: string, returnNullOnMissing?: boolean): string;
+        eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
+    }
+
+    export interface Mapping {
+        generated: Position;
+        original: Position;
+        source: string;
+        name?: string;
+    }
+
+    export class SourceMapGenerator {
+        constructor(startOfSourceMap?: StartOfSourceMap);
+        static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator;
+        addMapping(mapping: Mapping): void;
+        setSourceContent(sourceFile: string, sourceContent: string): void;
+        applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
+        toString(): string;
+    }
+
+    export interface CodeWithSourceMap {
+        code: string;
+        map: SourceMapGenerator;
+    }
+
+    export class SourceNode {
+        constructor();
+        constructor(line: number, column: number, source: string);
+        constructor(line: number, column: number, source: string, chunk?: string, name?: string);
+        static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode;
+        add(chunk: string): void;
+        prepend(chunk: string): void;
+        setSourceContent(sourceFile: string, sourceContent: string): void;
+        walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
+        walkSourceContents(fn: (file: string, content: string) => void): void;
+        join(sep: string): SourceNode;
+        replaceRight(pattern: string, replacement: string): SourceNode;
+        toString(): string;
+        toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
+    }
+}
+
+declare module 'source-map-js/lib/source-map-generator' {
+    import { SourceMapGenerator } from 'source-map-js'
+    export { SourceMapGenerator }
+}
+
+declare module 'source-map-js/lib/source-map-consumer' {
+    import { SourceMapConsumer } from 'source-map-js'
+    export { SourceMapConsumer }
+}
+
+declare module 'source-map-js/lib/source-node' {
+    import { SourceNode } from 'source-map-js'
+    export { SourceNode }
+}

package/website/node_modules/source-map-js/source-map.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;

package/website/node_modules/sucrase/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2018 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.

package/website/node_modules/sucrase/README.md

@@ -0,0 +1,295 @@
+# Sucrase
+
+[![Build Status](https://github.com/alangpierce/sucrase/workflows/All%20tests/badge.svg)](https://github.com/alangpierce/sucrase/actions)
+[![npm version](https://img.shields.io/npm/v/sucrase.svg)](https://www.npmjs.com/package/sucrase)
+[![Install Size](https://packagephobia.now.sh/badge?p=sucrase)](https://packagephobia.now.sh/result?p=sucrase)
+[![MIT License](https://img.shields.io/npm/l/express.svg?maxAge=2592000)](LICENSE)
+[![Join the chat at https://gitter.im/sucrasejs](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sucrasejs/Lobby)
+
+## [Try it out](https://sucrase.io)
+
+## Quick usage
+
+```bash
+yarn add --dev sucrase  # Or npm install --save-dev sucrase
+node -r sucrase/register main.ts
+```
+
+Using the [ts-node](https://github.com/TypeStrong/ts-node) integration:
+
+```bash
+yarn add --dev sucrase ts-node typescript
+./node_modules/.bin/ts-node --transpiler sucrase/ts-node-plugin main.ts
+```
+
+## Project overview
+
+Sucrase is an alternative to Babel that allows super-fast development builds.
+Instead of compiling a large range of JS features to be able to work in Internet
+Explorer, Sucrase assumes that you're developing with a recent browser or recent
+Node.js version, so it focuses on compiling non-standard language extensions:
+JSX, TypeScript, and Flow. Because of this smaller scope, Sucrase can get away
+with an architecture that is much more performant but less extensible and
+maintainable. Sucrase's parser is forked from Babel's parser (so Sucrase is
+indebted to Babel and wouldn't be possible without it) and trims it down to a
+focused subset of what Babel solves. If it fits your use case, hopefully Sucrase
+can speed up your development experience!
+
+**Sucrase has been extensively tested.** It can successfully build
+the [Benchling](https://benchling.com/) frontend code,
+[Babel](https://github.com/babel/babel),
+[React](https://github.com/facebook/react),
+[TSLint](https://github.com/palantir/tslint),
+[Apollo client](https://github.com/apollographql/apollo-client), and
+[decaffeinate](https://github.com/decaffeinate/decaffeinate)
+with all tests passing, about 1 million lines of code total.
+
+**Sucrase is about 20x faster than Babel.** Here's one measurement of how
+Sucrase compares with other tools when compiling the Jest codebase 3 times,
+about 360k lines of code total:
+
+```text
+            Time            Speed
+Sucrase     0.57 seconds    636975 lines per second
+swc         1.19 seconds    304526 lines per second
+esbuild     1.45 seconds    248692 lines per second
+TypeScript  8.98 seconds    40240 lines per second
+Babel       9.18 seconds    39366 lines per second
+```
+
+Details: Measured on July 2022. Tools run in single-threaded mode without warm-up. See the
+[benchmark code](https://github.com/alangpierce/sucrase/blob/main/benchmark/benchmark.ts)
+for methodology and caveats.
+
+## Transforms
+
+The main configuration option in Sucrase is an array of transform names. These
+transforms are available:
+
+* **jsx**: Enables JSX syntax. By default, JSX is transformed to `React.createClass`,
+  but may be preserved or transformed to `_jsx()` by setting the `jsxRuntime` option.
+  Also adds `createReactClass` display names and JSX context information.
+* **typescript**: Compiles TypeScript code to JavaScript, removing type
+  annotations and handling features like enums. Does not check types. Sucrase
+  transforms each file independently, so you should enable the `isolatedModules`
+  TypeScript flag so that the typechecker will disallow the few features like
+  `const enum`s that need cross-file compilation. The Sucrase option `keepUnusedImports`
+  can be used to disable all automatic removal of imports and exports, analogous to TS
+  `verbatimModuleSyntax`.
+* **flow**:  Removes Flow type annotations. Does not check types.
+* **imports**: Transforms ES Modules (`import`/`export`) to CommonJS
+  (`require`/`module.exports`) using the same approach as Babel and TypeScript
+  with `--esModuleInterop`. If `preserveDynamicImport` is specified in the Sucrase
+  options, then dynamic `import` expressions are left alone, which is particularly
+  useful in Node to load ESM-only libraries. If `preserveDynamicImport` is not
+  specified, `import` expressions are transformed into a promise-wrapped call to
+  `require`.
+* **react-hot-loader**: Performs the equivalent of the `react-hot-loader/babel`
+  transform in the [react-hot-loader](https://github.com/gaearon/react-hot-loader)
+  project. This enables advanced hot reloading use cases such as editing of
+  bound methods.
+* **jest**: Hoist desired [jest](https://jestjs.io/) method calls above imports in
+  the same way as [babel-plugin-jest-hoist](https://github.com/facebook/jest/tree/master/packages/babel-plugin-jest-hoist).
+  Does not validate the arguments passed to `jest.mock`, but the same rules still apply.
+
+When the `imports` transform is *not* specified (i.e. when targeting ESM), the
+`injectCreateRequireForImportRequire` option can be specified to transform TS
+`import foo = require("foo");` in a way that matches the
+[TypeScript 4.7 behavior](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7/#commonjs-interoperability)
+with `module: nodenext`.
+
+These newer JS features are transformed by default:
+
+* [Optional chaining](https://github.com/tc39/proposal-optional-chaining): `a?.b`
+* [Nullish coalescing](https://github.com/tc39/proposal-nullish-coalescing): `a ?? b`
+* [Class fields](https://github.com/tc39/proposal-class-fields): `class C { x = 1; }`.
+  This includes static fields but not the `#x` private field syntax.
+* [Numeric separators](https://github.com/tc39/proposal-numeric-separator):
+  `const n = 1_234;`
+* [Optional catch binding](https://github.com/tc39/proposal-optional-catch-binding):
+  `try { doThing(); } catch { }`.
+
+If your target runtime supports these features, you can specify
+`disableESTransforms: true` so that Sucrase preserves the syntax rather than
+trying to transform it. Note that transpiled and standard class fields behave
+slightly differently; see the
+[TypeScript 3.7 release notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#the-usedefineforclassfields-flag-and-the-declare-property-modifier)
+for details. If you use TypeScript, you can enable the TypeScript option
+`useDefineForClassFields` to enable error checking related to these differences.
+
+### Unsupported syntax
+
+All JS syntax not mentioned above will "pass through" and needs to be supported
+by your JS runtime. For example:
+
+* Decorators, private fields, `throw` expressions, generator arrow functions,
+  and `do` expressions are all unsupported in browsers and Node (as of this
+  writing), and Sucrase doesn't make an attempt to transpile them.
+* Object rest/spread, async functions, and async iterators are all recent
+  features that should work fine, but might cause issues if you use older
+  versions of tools like webpack. BigInt and newer regex features may or may not
+  work, based on your tooling.
+
+### JSX Options
+
+By default, JSX is compiled to React functions in development mode. This can be
+configured with a few options:
+
+* **jsxRuntime**: A string specifying the transform mode, which can be one of three values:
+  * `"classic"` (default): The original JSX transform that calls `React.createElement` by default.
+    To configure for non-React use cases, specify:
+    * **jsxPragma**: Element creation function, defaults to `React.createElement`.
+    * **jsxFragmentPragma**: Fragment component, defaults to `React.Fragment`.
+  * `"automatic"`: The [new JSX transform](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html)
+      introduced with React 17, which calls `jsx` functions and auto-adds import statements.
+    To configure for non-React use cases, specify:
+    * **jsxImportSource**: Package name for auto-generated import statements, defaults to `react`.
+  * `"preserve"`: Don't transform JSX, and instead emit it as-is in the output code.
+* **production**: If `true`, use production version of functions and don't include debugging
+  information. When using React in production mode with the automatic transform, this *must* be
+  set to true to avoid an error about `jsxDEV` being missing.
+
+### Legacy CommonJS interop
+
+Two legacy modes can be used with the `imports` transform:
+
+* **enableLegacyTypeScriptModuleInterop**: Use the default TypeScript approach
+  to CommonJS interop instead of assuming that TypeScript's `--esModuleInterop`
+  flag is enabled. For example, if a CJS module exports a function, legacy
+  TypeScript interop requires you to write `import * as add from './add';`,
+  while Babel, Webpack, Node.js, and TypeScript with `--esModuleInterop` require
+  you to write `import add from './add';`. As mentioned in the
+  [docs](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#support-for-import-d-from-cjs-form-commonjs-modules-with---esmoduleinterop),
+  the TypeScript team recommends you always use `--esModuleInterop`.
+* **enableLegacyBabel5ModuleInterop**: Use the Babel 5 approach to CommonJS
+  interop, so that you can run `require('./MyModule')` instead of
+  `require('./MyModule').default`. Analogous to
+  [babel-plugin-add-module-exports](https://github.com/59naga/babel-plugin-add-module-exports).
+
+## Usage
+
+### Tool integrations
+
+* [Webpack](https://github.com/alangpierce/sucrase/tree/main/integrations/webpack-loader)
+* [Gulp](https://github.com/alangpierce/sucrase/tree/main/integrations/gulp-plugin)
+* [Jest](https://github.com/alangpierce/sucrase/tree/main/integrations/jest-plugin)
+* [Rollup](https://github.com/rollup/plugins/tree/master/packages/sucrase)
+* [Broccoli](https://github.com/stefanpenner/broccoli-sucrase)
+
+### Usage in Node
+
+The most robust way is to use the Sucrase plugin for [ts-node](https://github.com/TypeStrong/ts-node),
+which has various Node integrations and configures Sucrase via `tsconfig.json`:
+```bash
+ts-node --transpiler sucrase/ts-node-plugin
+```
+
+For projects that don't target ESM, Sucrase also has a require hook with some
+reasonable defaults that can be accessed in a few ways:
+
+* From code: `require("sucrase/register");`
+* When invoking Node: `node -r sucrase/register main.ts`
+* As a separate binary: `sucrase-node main.ts`
+
+Options can be passed to the require hook via a `SUCRASE_OPTIONS` environment
+variable holding a JSON string of options.
+
+### Compiling a project to JS
+
+For simple use cases, Sucrase comes with a `sucrase` CLI that mirrors your
+directory structure to an output directory:
+```bash
+sucrase ./srcDir -d ./outDir --transforms typescript,imports
+```
+
+### Usage from code
+
+For any advanced use cases, Sucrase can be called from JS directly:
+
+```js
+import {transform} from "sucrase";
+const compiledCode = transform(code, {transforms: ["typescript", "imports"]}).code;
+```
+
+## What Sucrase is not
+
+Sucrase is intended to be useful for the most common cases, but it does not aim
+to have nearly the scope and versatility of Babel. Some specific examples:
+
+* Sucrase does not check your code for errors. Sucrase's contract is that if you
+  give it valid code, it will produce valid JS code. If you give it invalid
+  code, it might produce invalid code, it might produce valid code, or it might
+  give an error. Always use Sucrase with a linter or typechecker, which is more
+  suited for error-checking.
+* Sucrase is not pluginizable. With the current architecture, transforms need to
+  be explicitly written to cooperate with each other, so each additional
+  transform takes significant extra work.
+* Sucrase is not good for prototyping language extensions and upcoming language
+  features. Its faster architecture makes new transforms more difficult to write
+  and more fragile.
+* Sucrase will never produce code for old browsers like IE. Compiling code down
+  to ES5 is much more complicated than any transformation that Sucrase needs to
+  do.
+* Sucrase is hesitant to implement upcoming JS features, although some of them
+  make sense to implement for pragmatic reasons. Its main focus is on language
+  extensions (JSX, TypeScript, Flow) that will never be supported by JS
+  runtimes.
+* Like Babel, Sucrase is not a typechecker, and must process each file in
+  isolation. For example, TypeScript `const enum`s are treated as regular
+  `enum`s rather than inlining across files.
+* You should think carefully before using Sucrase in production. Sucrase is
+  mostly beneficial in development, and in many cases, Babel or tsc will be more
+  suitable for production builds.
+
+See the [Project Vision](./docs/PROJECT_VISION.md) document for more details on
+the philosophy behind Sucrase.
+
+## Motivation
+
+As JavaScript implementations mature, it becomes more and more reasonable to
+disable Babel transforms, especially in development when you know that you're
+targeting a modern runtime. You might hope that you could simplify and speed up
+the build step by eventually disabling Babel entirely, but this isn't possible
+if you're using a non-standard language extension like JSX, TypeScript, or Flow.
+Unfortunately, disabling most transforms in Babel doesn't speed it up as much as
+you might expect. To understand, let's take a look at how Babel works:
+
+1. Tokenize the input source code into a token stream.
+2. Parse the token stream into an AST.
+3. Walk the AST to compute the scope information for each variable.
+4. Apply all transform plugins in a single traversal, resulting in a new AST.
+5. Print the resulting AST.
+
+Only step 4 gets faster when disabling plugins, so there's always a fixed cost
+to running Babel regardless of how many transforms are enabled.
+
+Sucrase bypasses most of these steps, and works like this:
+
+1. Tokenize the input source code into a token stream using a trimmed-down fork
+   of the Babel parser. This fork does not produce a full AST, but still
+   produces meaningful token metadata specifically designed for the later
+   transforms.
+2. Scan through the tokens, computing preliminary information like all
+   imported/exported names.
+3. Run the transform by doing a pass through the tokens and performing a number
+   of careful find-and-replace operations, like replacing `<Foo` with
+   `React.createElement(Foo`.
+
+Because Sucrase works on a lower level and uses a custom parser for its use
+case, it is much faster than Babel.
+
+## Contributing
+
+Contributions are welcome, whether they be bug reports, PRs, docs, tests, or
+anything else! Please take a look through the [Contributing Guide](./CONTRIBUTING.md)
+to learn how to get started.
+
+## License and attribution
+
+Sucrase is MIT-licensed. A large part of Sucrase is based on a fork of the
+[Babel parser](https://github.com/babel/babel/tree/main/packages/babel-parser),
+which is also MIT-licensed.
+
+## Why the name?
+
+Sucrase is an enzyme that processes sugar. Get it?

package/website/node_modules/sucrase/bin/sucrase

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/cli").default();

package/website/node_modules/sucrase/bin/sucrase-node

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+const Module = require("module");
+const {resolve} = require("path");
+
+/*
+ * Simple wrapper around node that first registers Sucrase with default settings.
+ *
+ * This is meant for simple use cases, and doesn't support custom Node/V8 args,
+ * executing a code snippet, a REPL, or other things that you might find in
+ * node, babel-node, or ts-node. For more advanced use cases, you can use
+ * `node -r sucrase/register` or register a require hook programmatically from
+ * your own code.
+ */
+require("../register");
+
+process.argv.splice(1, 1);
+process.argv[1] = resolve(process.argv[1]);
+Module.runMain();