├── .github
    ├── dependabot.yml
    └── workflows
    │   └── node.js.yml
├── .gitignore
├── .npmignore
├── BENEFITS.md
├── DRAWBACKS.md
├── LICENSE
├── PROPOSAL.md
├── README.md
├── WHY_NEST_IMPORTS.md
├── examples
    ├── babel-parser-example
    │   ├── README.md
    │   ├── index.js
    │   ├── module.js
    │   ├── package-lock.json
    │   └── package.json
    ├── custom-cache-example
    │   ├── README.md
    │   ├── index.js
    │   ├── module.js
    │   └── package.json
    └── top-level-example
    │   ├── README.md
    │   ├── index.js
    │   ├── module.js
    │   └── package.json
├── lib
    ├── assignment-visitor.js
    ├── compiler.js
    ├── empty.js
    ├── fast-object.js
    ├── fast-path.js
    ├── import-export-visitor.js
    ├── options.js
    ├── parsers
    │   ├── acorn-extensions
    │   │   ├── export.js
    │   │   ├── import.js
    │   │   ├── index.js
    │   │   └── tolerance.js
    │   ├── acorn.js
    │   ├── babel.js
    │   ├── babylon.js
    │   ├── default.js
    │   └── top-level.js
    ├── runtime
    │   ├── entry.js
    │   ├── index.js
    │   └── utils.js
    ├── transform.js
    ├── utils.js
    └── visitor.js
├── node
    ├── caching-compiler.js
    ├── compile-hook.js
    ├── data.js
    ├── fs.js
    ├── index.js
    ├── pkg-info.js
    ├── repl-hook.js
    ├── utils.js
    ├── version.js
    └── wrapper.js
├── package-lock.json
├── package.json
├── plugins
    └── babel.js
├── repl
    └── index.js
└── test
    ├── all-files.js
    ├── babel-plugin-tests.js
    ├── cjs
        ├── bridge.js
        ├── export-default-property.js
        ├── module-exports-esModule.js
        ├── module-exports-function.js
        ├── module-exports-null.js
        └── module-exports-object.js
    ├── compiler-tests.js
    ├── compiler
        ├── lines.js
        └── strict.js
    ├── default-expression.js
    ├── default-function.js
    ├── export-tests.js
    ├── export
        ├── all-lodash.js
        ├── all-multiple.js
        ├── all-mutual-a.js
        ├── all-mutual-b.js
        ├── all.js
        ├── array-pattern-holes.js
        ├── class.js
        ├── common.js
        ├── cycle-a.js
        ├── cycle-b.js
        ├── declarations.js
        ├── declarations
        │   ├── basic.js
        │   └── block.js
        ├── def.js
        ├── default-expression.js
        ├── default-function.js
        ├── default
        │   ├── anon-class.js
        │   ├── anon-function.js
        │   ├── array.js
        │   ├── from.js
        │   ├── function.js
        │   ├── identifier.js
        │   ├── named-class.js
        │   ├── number.js
        │   └── object.js
        ├── destructuring.js
        ├── extensions.js
        ├── from-ordering-a.js
        ├── from-ordering-b.js
        ├── from-ordering-c.js
        ├── from-ordering-common.js
        ├── from-ordering.js
        ├── from.js
        ├── later.js
        ├── names.js
        ├── nested.js
        ├── renamed.js
        ├── sealed.js
        ├── shadowed.js
        ├── some.js
        └── swap-later.js
    ├── file-extension-tests.js
    ├── file-extension
        └── a.mjs
    ├── hoisting-tests.js
    ├── hoisting
        ├── a.js
        └── b.js
    ├── import-tests.js
    ├── import
        ├── cycle-a.js
        ├── cycle-b.js
        ├── extensions.js
        └── name.js
    ├── misc-tests.js
    ├── misc
        ├── abc.js
        ├── export-all-with-default.js
        ├── export-all.js
        ├── export-default.js
        ├── live.js
        ├── order-a.js
        ├── order-b.js
        ├── order-c.js
        ├── order-tracker.js
        └── risky-exports.js
    ├── node_modules
        ├── disabled
        │   └── index.js
        └── enabled
        │   ├── enabled.js
        │   └── package.json
    ├── output-tests.js
    ├── output
        ├── anon-class
        │   ├── actual.js
        │   └── expected.js
        ├── declarations-basic
        │   ├── actual.js
        │   └── expected.js
        ├── default-expression
        │   ├── actual.js
        │   └── expected.js
        ├── default-function
        │   ├── actual.js
        │   └── expected.js
        ├── eval
        │   ├── actual.js
        │   └── expected.js
        ├── export-all-multiple
        │   ├── actual.js
        │   └── expected.js
        ├── export-all
        │   ├── actual.js
        │   └── expected.js
        ├── export-multi-namespace
        │   ├── actual.js
        │   └── expected.js
        ├── export-some
        │   ├── actual.js
        │   └── expected.js
        ├── lines
        │   ├── actual.js
        │   └── expected.js
        ├── live
        │   ├── actual.js
        │   └── expected.js
        ├── mixed-keys
        │   ├── actual.js
        │   └── expected.js
        ├── name
        │   ├── actual.js
        │   └── expected.js
        ├── nested
        │   ├── actual.js
        │   └── expected.js
        ├── only-nested
        │   ├── actual.js
        │   └── expected.js
        └── strict
        │   ├── actual.js
        │   └── expected.js
    ├── package.json
    ├── repl-tests.js
    ├── run.js
    ├── run.sh
    ├── setter-tests.js
    ├── setter
        ├── child.js
        ├── cycle
        │   ├── cjs.js
        │   └── esm.js
        ├── eval.js
        ├── fake-const.js
        ├── grandchild.js
        └── parent.js
    ├── tests.js
    ├── transform-tests.js
    └── undeclared-export.js


/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | # Please see the documentation for all configuration options:
 2 | # https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
 3 | 
 4 | version: 2
 5 | updates:
 6 |   - package-ecosystem: "npm" # See documentation for possible values
 7 |     directory: "/" # Location of package manifests
 8 |     schedule:
 9 |       interval: "daily"
10 | 


--------------------------------------------------------------------------------
/.github/workflows/node.js.yml:
--------------------------------------------------------------------------------
 1 | # This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
 2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
 3 | 
 4 | name: Node.js CI
 5 | 
 6 | on:
 7 |   push:
 8 |     branches: [ main ]
 9 |   pull_request:
10 |     branches: [ main ]
11 | 
12 | jobs:
13 |   build:
14 | 
15 |     runs-on: ubuntu-latest
16 | 
17 |     strategy:
18 |       matrix:
19 |         node-version: [10.x, 12.x, 14.x, 15.x, 16.x]
20 |         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
21 | 
22 |     steps:
23 |     - uses: actions/checkout@v2
24 |     - name: Use Node.js ${{ matrix.node-version }}
25 |       uses: actions/setup-node@v1
26 |       with:
27 |         node-version: ${{ matrix.node-version }}
28 |     - run: npm ci
29 |     - run: npm run build --if-present
30 |     - run: npm test
31 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | *.log
3 | test/.cache
4 | test/**/*.gz
5 | node_modules
6 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | /examples
2 | /node_modules
3 | /packages
4 | /test
5 | 


--------------------------------------------------------------------------------
/BENEFITS.md:
--------------------------------------------------------------------------------
 1 | Benefits
 2 | ---
 3 | * Dead-simple installation and setup: `npm install --save reify`, `require("reify")`
 4 | * Works with every version of Node.
 5 | * Put `import` and `export` statements anywhere you like.
 6 |   * They're just statements.
 7 |   * If you have a philosophical preference for restricting them to the top-level, there are plenty of ways to enforce that.
 8 |   * This library doesn't limit you either way.
 9 | * Imported symbols are just normal variables.
10 |   * Debuggers and dev tools display the symbols as you wrote them, unmangled by a transpiler.
11 |   * Not having to rename variables references leads to much faster compilation.
12 |   * Variables are confined to the scope where they were imported.
13 |   * `import` statements work in the Node REPL.
14 | * Any existing module or package can be imported.
15 |   * Babel's `interopRequire{Default,Wildcard}` logic is captured by `Module.prototype.getExportByName`.
16 | * Does not interfere with existing `require.extensions` hooks.
17 | * Much simpler transform implementation as compared with other ECMASCript module compilers.
18 |   * `import` statements become calls to `module.importSync(id, setters)`
19 |   * `export` statements become assignments to the `exports` object.
20 |   * The compiler doesn't have to parse the entire file to find `import` and `export` statements.
21 | * Line numbers are strictly preserved.
22 |   * No hoisting of `import` statements.
23 |   * All `import` and `export` statements are compiled in-place.
24 | * No need for `Object.defineProperty`-style getters to support `export * from "..."`.
25 | * The `module.importSync(id, setters)` API is human-writable, too, if you want to implement custom update logic.
26 | * Generated code is statically analyzable, since the `exports` object is not exposed.
27 | 


--------------------------------------------------------------------------------
/DRAWBACKS.md:
--------------------------------------------------------------------------------
 1 | Drawbacks
 2 | ---
 3 | 
 4 | * Only works with CommonJS module systems that are very similar to Node's module system.
 5 | * Adds some overhead to module evaluation.
 6 | * ~~Affects every yet-to-be required module in the Node process.~~<br>
 7 |   _Only modules in packages that explicitly depend on `reify`._
 8 | * Not a general solution for other kinds of JavaScript compilation.
 9 | * Not a solution for asynchronous module loading, yet.
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Ben Newman
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/PROPOSAL.md:
--------------------------------------------------------------------------------
  1 | # ECMAScript Proposal: Nested `import` declarations
  2 | 
  3 | **Stage:** 0
  4 | 
  5 | **Champion:** Ben Newman (Meteor Development Group)
  6 | 
  7 | **Specification:** Work in progress; see attached [commits](https://github.com/tc39/ecma262/pull/646/commits).
  8 | 
  9 | 
 10 | ## Summary
 11 | 
 12 | This proposal argues for relaxing the current restriction that `import` declarations may appear only at the top level of a module.
 13 | 
 14 | Specifically, this proposal would allow `import` declarations that are
 15 | 
 16 | 1. **nestable** within functions and blocks, enabling multiple new and worthwhile `import` idioms;
 17 | 1. **hoisted** to the beginning of the enclosing scope; that is, _declarative_ rather than _imperative_;
 18 | 1. **lexically scoped** to the enclosing block;
 19 | 1. **synchronously evaluated**, with clear and manageable consequences for runtime module fetching; and
 20 | 1. **backwards compatible** with the semantics of existing top-level `import` declarations.
 21 | 
 22 | At this time, no changes are proposed regarding the placement or semantics of `export` declarations. In the opinion of the author, keeping all `export` declarations at the top level remains important for many of the static properties of the ECMAScript module system.
 23 | 
 24 | 
 25 | ## Motivating examples
 26 | 
 27 | ### Isolated scopes
 28 | 
 29 | Consider writing a simple BDD-style unit test that involves importing a symbol called `check` from three different modules:
 30 | 
 31 | ```js
 32 | describe("fancy feature #5", () => {
 33 |   import { strictEqual } from "assert";
 34 | 
 35 |   it("should work on the client", () => {
 36 |     import { check } from "./client.js";
 37 |     strictEqual(check(), "client ok");
 38 |   });
 39 | 
 40 |   it("should work on the server", () => {
 41 |     import { check } from "./server.js";
 42 |     strictEqual(check(), "server ok");
 43 |   });
 44 | 
 45 |   it("should work on both client and server", () => {
 46 |     import { check } from "./both.js";
 47 |     strictEqual(check(), "both ok");
 48 |   });
 49 | });
 50 | ```
 51 | 
 52 | If `import` declarations could not appear in nested scopes, you would have to write this code differently:
 53 | 
 54 | ```js
 55 | import { strictEqual } from "assert";
 56 | import { check as checkClient } from "./client.js";
 57 | import { check as checkServer } from "./server.js";
 58 | import { check as checkBoth } from "./both.js";
 59 | 
 60 | describe("fancy feature #5", () => {
 61 |   it("should work on the client", () => {
 62 |     strictEqual(checkClient(), "client ok");
 63 |   });
 64 | 
 65 |   it("should work on the client", () => {
 66 |     strictEqual(checkServer(), "server ok");
 67 |   });
 68 | 
 69 |   it("should work on both client and server", () => {
 70 |     strictEqual(checkBoth(), "both ok");
 71 |   });
 72 | });
 73 | ```
 74 | 
 75 | This manual renaming is annoying, and potentially surprising to developers coming from other languages (or even Node), so there needs to be a good reason why it's necessary in JavaScript. Conversely, if it isn't necessary, because there exists a reasonable implementation of nested `import` declarations, then it becomes harder to claim we have a good reason for the top-level restriction.
 76 | 
 77 | In the second version of this code, since the `import` declarations are evaluated before the tests are defined, any exceptions thrown by importing the modules will prevent your tests from running at all! Compare this behavior to that of the original code, where each test captures any and all exceptions resulting from its own particular `import` declaration and `strictEqual(check(), ...)` call.
 78 | 
 79 | ### Lazy evaluation
 80 | 
 81 | As the previous example suggests, putting all your `import` declarations at the top level of your modules means you pay the performance cost of evaluating all your modules at startup time, even if they are not used until much later&mdash;or in some cases never used at all.
 82 | 
 83 | If you have the ability to nest `import` declarations in the immediate scope where the imported symbols will be used, then you can take full advantage of your application's specific needs, and there is nothing to stop you from front-loading your imports if that makes sense for your application.
 84 | 
 85 | Eager evaluation of the entire dependency tree is fine for long-running applications like servers, but not so great for short-lived, multi-purpose utilities like command-line tools, or client-side applications that must evaluate modules while the user waits. For example, the [WebTorrent Desktop app](https://webtorrent.io/) was able to reduce startup time dramatically [by deferring `require` calls](https://mobile.twitter.com/WebTorrentApp/status/737890973733244928). This optimization would not have been possible if they could only use `import` declarations at the top level.
 86 | 
 87 | ### Colocation of `import` declarations with consuming code
 88 | 
 89 | When you delete code that contains a nested `import` declaration, you don't have to scroll up to the top of the file and search through a laundry list of other `import` declarations, then search through the rest of the file for any other references to the imported symbols. The scope of the nested `import` declaration is obvious, so it's easy to tell when it's safe to delete.
 90 | 
 91 | ### Optimistic imports
 92 | 
 93 | Perhaps you would like to use a module if it is available, but it's hardly the end of the world if it's not:
 94 | 
 95 | ```js
 96 | try {
 97 |   import esc from "enhanced-super-console";
 98 |   console = esc;
 99 | } catch (e) {
100 |   // That's ok, we'll just stick to the usual implementations of
101 |   // console.log, .error, .trace, etc., or stub them out.
102 | }
103 | ```
104 | 
105 | Without the ability to nest `import` declarations inside `try`-`catch` blocks, there would be no way to achieve this progressive enhancement of the `console` object.
106 | 
107 | 
108 | ### Dead code elimination
109 | 
110 | Nested `import` declarations make certain static optimizations significantly more effective; for example, dead code elimination via constant propagation.
111 | 
112 | A sophisticated bundling tool might eliminate unreachable code based on the known values of certain constants:
113 | 
114 | ```js
115 | if (__USER_ROLE__ === "admin") {
116 |   import { setUpAdminTools } from "../admin/tools";
117 |   setUpAdminTools(user.id);
118 | }
119 | ```
120 | 
121 | Ideally this code would disappear completely from your public JavaScript assets (whenever `__USER_ROLE__ !== "admin"`), along with the `../admin/tools` module, assuming it is not used elsewhere by non-admin code.
122 | 
123 | > Aside: when `__USER_ROLE__ === "admin"`, note that the body of the condition must remain a block statement, so that `setUpAdminTools` remains scoped to that block, rather than becoming visible to surrounding code.  In other words, nested `import`s are still important even after dead code elimination has taken place.
124 | 
125 | Without the ability to nest `import` declarations inside conditional blocks, dead code elimination becomes the responsibility of the imported module. You would likely have to wrap the entire body of the `../admin/tools` module with a conditional block, and even then the empty `../admin/tools` module would still be included in the public bundle, which might constitute a leak of sensitive information.
126 | 
127 | Worse still, as long as `import` declarations are restricted to the top level, the `import`s of `../admin/tools` cannot be included in the conditional block, making any kind of dead module elimination impossible.
128 | 
129 | 
130 | ## Semantic details
131 | 
132 | ### Backwards compatibility
133 | 
134 | At this stage of the ECMAScript specification, any backwards-incompatible change to the existing semantics of top-level `import` declarations would require extraordinary motivation.
135 | 
136 | This proposal makes no such suggestion. In fact, the viability of this proposal very much hinges on the technical possibility of allowing nested `import` declarations without breaking existing code.
137 | 
138 | For example (while I do not consider the precise evaluation order of modules to be a matter of backwards compatibility), I see no reason why a program that uses only top-level `import` declarations should necessarily evaluate its modules in a different order, just because nested `import` declarations are allowed.
139 | 
140 | In other words, I am proposing a strict expansion of the possible use cases for `import` declarations.
141 | 
142 | 
143 | ### Nesting
144 | 
145 | In terms of the grammar, I propose that
146 | 
147 | &nbsp;&nbsp;&nbsp;&nbsp;_ModuleItem_ :<br>
148 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_ImportDeclaration_<br>
149 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_ExportDeclaration_<br>
150 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_StatementListItem_
151 | 
152 | &nbsp;&nbsp;&nbsp;&nbsp;_StatementListItem_ :<br>
153 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_Statement_<br>
154 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_Declaration_
155 | 
156 | be modified as follows:
157 | 
158 | &nbsp;&nbsp;&nbsp;&nbsp;_ModuleItem_ :<br>
159 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_ExportDeclaration_<br>
160 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_StatementListItem_
161 | 
162 | &nbsp;&nbsp;&nbsp;&nbsp;_StatementListItem_ :<br>
163 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_Statement_<br>
164 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_Declaration_<br>
165 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_ImportDeclaration_
166 | 
167 | This modification has a few subtleties worth highlighting:
168 | 
169 | * It is important that _ImportDeclaration_ not be producible by a _Statement_ or a _Declaration_, else an _ExportDeclaration_ could export an _ImportDeclaration_, which is presumably undesirable.
170 | 
171 | * This grammar would not allow `import` declarations of the following form:
172 | 
173 |   ```js
174 |   if (condition) import "./sometimes";
175 |   ```
176 |   though it would allow
177 |   ```js
178 |   if (condition) {
179 |     import "./sometimes";
180 |   }
181 |   ```
182 |   Though potentially surprising, this seems reasonable on the grounds that
183 |   ```js
184 |   if (condition) let foo = bar;
185 |   ```
186 |   is also currently illegal. However, if we want to allow braceless nested `import` declarations, it should be possible to modify the grammar for _IfStatement_ et al., so that the body/consequent/alternate can be either a _Statement_ or an _ImportDeclaration_.
187 | 
188 | * It is not immediately obvious from this new grammar that an _ImportDeclaration_ may only appear in a _Module_. I believe the specification should enforce this restriction, but I am currently unsure how best to do so. As I understand it, there are three possibilities:
189 | 
190 |   * Thread <sub>[Import]</sub> subscripts throughout the grammar, similar to
191 |     <sub>[Yield,Return]</sub>.
192 |   * Verbally forbid _ImportDeclaration_ from appearing unless the goal symbol
193 |     is _Module_.
194 |   * Rely on runtime errors.
195 | 
196 | 
197 | ### Declarative hoisting
198 | 
199 | TC39 has [previously discussed](https://github.com/tc39/ecma262/issues/368) at length whether `import` declarations should be *declarative* or *imperative*. In short, declarative `import` declarations take effect before any other code in the scope where the declaration appears, whereas imperative declarations may be interleaved with other declarations and statements.
200 | 
201 | I believe nested `import` declarations allow an elegant synthesis of these two possible semantic choices.
202 | 
203 | For selfish reasons, I was initially skeptical of declarative `import` declarations, because the imperative semantics are easier to implement with a [transpiler](https://github.com/benjamn/reify#how-it-works).  Declarative `import` declarations require "hoisting" code to the beginning of the enclosing block, whereas imperative declarations can simply be rewritten in place.
204 | 
205 | However, as I began to investigate the consequences of hoisting, I too became convinced that relying on the interleaving of `import` declarations with other statements is almost always a source of bugs, because you can only rarely know with confidence whether a particular `import` declaration is the first evaluator of the imported module.
206 | 
207 | With that said, there are occasionally scenarios where it's frustrating that you can't just put a `debugger` statement before an `import` declaration and step into the imported module, wrap an `import` declaration with timing code, or carefully manage the order of exports between two mutually dependent modules.
208 | 
209 | For those few scenarios, nested `import` declarations provide a convenient way of achieving imperative behavior: simply wrap the `import` in a `{...}` block statement or a function:
210 | 
211 | ```js
212 | import { a, b } from "./ab";
213 | 
214 | // Execution might hit this debugger statement before the "./xy" module is
215 | // imported, if it has not been imported before.
216 | debugger;
217 | {
218 |   import { x, y } from "./xy";
219 | }
220 | 
221 | console.log("x", getX());
222 | 
223 | // Imperatively import { x } from "./xy", and return it.
224 | function getX() {
225 |   import { x } from "./xy";
226 |   return x;
227 | }
228 | 
229 | // If you care about the latest live value of x, return a closure.
230 | function getXFn() {
231 |   import { x } from "./xy";
232 |   return () => x;
233 | }
234 | 
235 | const getX2 = getXFn();
236 | 
237 | setTimeout(() => {
238 |   console.log("current x:", getX2());
239 | }, delay);
240 | ```
241 | 
242 | Even if you find this syntax clunky, and even if you don't end up using it in production code, you have to admit it's useful when you need it in development.
243 | 
244 | In other words, **nested `import` declarations clear the way for embracing declarative `import` semantics by default**, because nested `import` declarations provide a graceful escape hatch in rare cases when you think you need imperative `import` semantics.
245 | 
246 | 
247 | ### Lexical scoping
248 | 
249 | If `import` declarations are hoisted to the beginning of the enclosing block, it seems natural that the imported symbols would have visibility similar to `const`- or `let`-declared variables, rather than `var` declarations. The goal of hoisting is to make imported symbols reliably usable throughout the enclosing block, so exposing the symbols outside that block would undermine the benefits of hoisting.
250 | 
251 | I consider this point relatively uncontroversial, and perhaps even already implied by the specification, since a module is effectively a block scope within which top-level imported symbols are confined (i.e., they do not leak into the global environment).
252 | 
253 | If you need to use an imported value outside the block where it was imported, you would need to assign it to a variable in the outer scope. If you are worried about the symbol changing values due to live binding, then you can create a closure in the scope of the `import` declaration that refers to the current value of the imported symbol, assign the closure function to some outer variable, and call that function to access the latest value of the imported symbol.
254 | 
255 | 
256 | ### Synchronous evaluation
257 | 
258 | Given that the [WHATWG Loader Standard](https://github.com/whatwg/loader) has adopted an asynchronous (`Promise`-based) API for module loading, it is tempting to imagine a desugaring from `import` declarations to something like `await` expressions, e.g.
259 | 
260 | ```js
261 | import { a, b } from "./c";
262 | ```
263 | 
264 | might be interpreted as
265 | 
266 | ```js
267 | const { a, b } = await loader.import("./c");
268 | ```
269 | 
270 | This desugaring story has a number of fundamental flaws that lead me to believe nested `import` declarations should not be explained through desugaring, and that the `loader.import` API should continue to serve the important role of enabling _explicit_ asynchronous module loading.
271 | 
272 | Problems with desugaring to asynchronous forms:
273 | 
274 | * JavaScript has a strong precedent against any kind of implicit asynchronicity, or non-cooperative preemption, which is why we have `yield` and `await` instead of full coroutines or threads. Asynchronous module loading should be done explicitly using the `Promise`-based Loader API (or `<script type=module>`).
275 | 
276 | * Conditional imports with dynamic conditions would summon the spectre of [Z&#856;&#844;&#859;&#864;&#794;&#844;&#804;&#846;&#809;&#798;&#827;&#801;&#807;&#841;&#809;&#824;a&#789;&#780;&#784;&#850;&#862;&#783;&#771;&#768;&#819;&#813;&#800;&#866;&#857;&#827;&#826;&#860;&#813;l&#786;&#786;&#779;&#835;&#768;&#862;&#825;&#839;&#845;&#853;&#837;&#798;&#822;g&#850;&#833;&#772;&#850;&#850;&#776;&#793;&#791;&#866;&#806;&#812;&#840;&#814;&#805;&#824;o&#833;&#786;&#785;&#830;&#789;&#780;&#862;&#793;&#854;&#799;&#804;&#815;&#815;](http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony).
277 | 
278 | * If we make nested `import` declarations asynchronous, then for consistency we should make top-level `import` declarations behave the same way, but that would likely be a backwards-incompatible change.
279 | 
280 | * A sequence of `import` declarations would have to be awaited in series rather than in parallel, because interleaving module execution is not acceptable, but that would mean missing the important opportunity to fetch module _sources_ in parallel.
281 | 
282 | * The `const { a, b } =` destructuring above does not behave identically to live immutable bindings, and it's not immediately obvious how any simple desugaring could faithfully achieve live-binding semantics.
283 | 
284 | * Most importantly, assuming a reasonable runtime strategy for synchronously evaluating `import` declarations exists (and it does!), we should strongly prefer it over any asynchronous alternative.
285 | 
286 | 
287 | #### How synchronous `import` declarations would work in browsers
288 | 
289 | When designing the JavaScript specification, we have a unique responsibility to consider the burdens we may be imposing on client-side implementations of the language.
290 | 
291 | While most other programming language environments (including Node) can assume their modules are immediately available, JavaScript running in the browser must fetch any unavailable modules over the network, and it is too late to perform that fetching at the point when an `import` declaration needs to be evaluated.
292 | 
293 | What then is the deadline for completing any asynchronous module fetching?  Although there may be situations where a sophisticated runtime can be more clever, in general the runtime must fetch the transitive closure of module dependencies _before it begins to evaluate the entry point module_.
294 | 
295 | In other words, the `System.import(id)` or `<script type=module>` that loads the original entry point module must first
296 | 
297 | 1. fetch the source for the entry point module;
298 | 1. scan it for requested module identifier strings (which does not require a full parse!);
299 | 1. resolve those requested module identifiers relative to the parent module;
300 | 1. asynchronously fetch the sources of the requested modules (in parallel);
301 | 1. scan the requested modules for additional dependencies;
302 | 1. fetch their sources in parallel;
303 | 1. etc. etc. until closure reached; and
304 | 1. only then begin evaluating the entry point module, with full confidence
305 |    that all requested modules will be immediately available.
306 | 
307 | This process certainly sounds expensive, but it is really no different from what the browser must already do to support top-level `import` declarations.  Think about it: if you can't nest `import` declarations, you have to hoist them manually to the top level anyway, which does not change the HTTP workload of the runtime at all!
308 | 
309 | From the perspective of the fetching process, all requested module identifier strings are treated the same, whether top-level or nested. Without fancy static analysis, all requested module identifiers must be regarded as dependencies that _might_ be immediately evaluated by the module. Moving `import` declarations in and out of nested scopes does not affect the set of dependencies requested by the module.  So again, nested `import` declarations do not invite any new performance problems.
310 | 
311 | And while it might seem easier to parse `import` declarations at the top level, remember that parsing the top level still requires examining the entire module. It should come as some relief (regardless of this proposal) that this process does not require a full parse, because the runtime can simply tokenize the module source until it hits an `import` or `export` token, then begin parsing from that starting point. This works equally well whether the declaration is at the top level or in some nested scope. The token stream can even be saved for later, if desired.
312 | 
313 | Though this process may involve many HTTP requests for a large application, those requests can be highly parallel, and performance will benefit from technologies like HTTP/2 and Service Workers. I would just recommend that the fetching protocol permit servers to return more modules than requested, so that the depth of the request tree can be minimized by sophisticated developers.
314 | 
315 | 
316 | ## Conclusion
317 | 
318 | I hope that this document convinces you that backwards-compatible, nestable, declarative, lexically scoped, synchronous `import` declarations are viable and desirable.
319 | 
320 | More generally, I hope that the existence of this proposal will invite specific technical discussion, and finally put to rest the question-begging objection that nested `import` declarations are "forbidden by the ECMAScript specification."
321 | 
322 | That's exactly what I'm trying to change, after all.
323 | 
324 | ## FAQ
325 | 
326 | TBD
327 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # re&middot;i&middot;fy <sub>_verb, transitive_</sub> &nbsp; [![Build Status](https://github.com/benjamn/reify/actions/workflows/node.js.yml/badge.svg)](https://github.com/benjamn/reify/actions/workflows/node.js.yml)
  2 | 
  3 | **re&middot;i&middot;fied** <sub>past</sub> &nbsp; **re&middot;i&middot;fies** <sub>present</sub> &nbsp; **re&middot;i&middot;fy&middot;ing** <sub>participle</sub> &nbsp; **re&middot;i&middot;fi&middot;ca&middot;tion** <sub>noun</sub> &nbsp; **re&middot;i&middot;fi&middot;er** <sub>noun</sub>
  4 | 
  5 |   1. to make (something abstract) more concrete or real<br>
  6 |      _"these instincts are, in humans, reified as verbal constructs"_
  7 |   2. to regard or treat (an idea, concept, etc.) as if having material existence
  8 |   3. **to enable [ECMAScript 2015 modules](http://www.2ality.com/2014/09/es6-modules-final.html) in *any* version of [Node.js](https://nodejs.org)**
  9 | 
 10 | Usage
 11 | ---
 12 | 
 13 |   1. Run `npm install --save reify` in your package or app directory. The
 14 |      `--save` is important because reification only applies to modules in
 15 |      packages that explicitly depend on the `reify` package.
 16 |   2. Call `require("reify")` before importing modules that contain `import`
 17 |      and `export` declarations.
 18 | 
 19 | You can also easily `reify` the Node REPL:
 20 | 
 21 | ```sh
 22 | % node
 23 | > require("reify")
 24 | {}
 25 | > import { strictEqual } from "assert"
 26 | > strictEqual(2 + 2, 5)
 27 | AssertionError: 4 === 5
 28 |     at repl:1:1
 29 |     at REPLServer.defaultEval (repl.js:272:27)
 30 |   ...
 31 | ```
 32 | 
 33 | How it works
 34 | ---
 35 | 
 36 | Code generated by the `reify` compiler relies on a [simple runtime
 37 | API](lib/runtime.js) that can be explained through a series of
 38 | examples. While you do not have to write this API by hand, it is designed
 39 | to be easily human readable and writable, in part because that makes it
 40 | easier to explain.
 41 | 
 42 | I will explain the `Module.prototype.link` method first, then the
 43 | `Module.prototype.export` method after that. Note that this `Module` is
 44 | the constructor of the CommonJS `module` object, and the `import` and
 45 | `export` methods are custom additions to `Module.prototype`.
 46 | 
 47 | ### `module.link(id, setters)`
 48 | 
 49 | Here we go:
 50 | 
 51 | ```js
 52 | import a, { b, c as d } from "./module";
 53 | ```
 54 | 
 55 | becomes
 56 | 
 57 | ```js
 58 | // Local symbols are declared as ordinary variables.
 59 | let a, b, d;
 60 | module.link("./module", {
 61 |   // The keys of this object literal are the names of exported symbols.
 62 |   // The values are setter functions that take new values and update the
 63 |   // local variables.
 64 |   default(value) { a = value; },
 65 |   b(value) { b = value; },
 66 |   c(value) { d = value; },
 67 | });
 68 | ```
 69 | 
 70 | All setter functions are called synchronously before `module.link` returns,
 71 | with whatever values are immediately available. However, when there are
 72 | import cycles, some setter functions may be called again, when the exported
 73 | values change. Calling these setter functions one or more times is the key
 74 | to implementing [*live bindings*](http://www.2ality.com/2015/07/es6-module-exports.html),
 75 | as required by the ECMAScript 2015 specification.
 76 | 
 77 | Importing a namespace object is no different from importing a named
 78 | export. The name is simply `"*"` instead of a legal identifier:
 79 | 
 80 | ```js
 81 | import * as utils from "./utils";
 82 | ```
 83 | becomes
 84 | ```js
 85 | let utils;
 86 | module.link("./utils", {
 87 |   "*"(ns) { utils = ns; }
 88 | });
 89 | ```
 90 | 
 91 | Note that the `ns` object exposed here is `!== require("./utils")`, but
 92 | instead a normalized view of the `require("./utils")` object. This
 93 | approach ensures that the actual `exports` object is never exposed to the
 94 | caller of `module.link`.
 95 | 
 96 | Notice that this compilation strategy works equally well no matter where
 97 | the `import` declaration appears:
 98 | 
 99 | ```js
100 | if (condition) {
101 |   import { a as b } from "./c";
102 |   console.log(b);
103 | }
104 | ```
105 | becomes
106 | ```js
107 | if (condition) {
108 |   let b;
109 |   module.link("./c", {
110 |     a(value) { b = value; }
111 |   });
112 |   console.log(b);
113 | }
114 | ```
115 | 
116 | See [`WHY_NEST_IMPORTS.md`](WHY_NEST_IMPORTS.md) for a much more detailed
117 | discussion of why nested `import` declarations are worthwhile.
118 | 
119 | ### `module.export(getters)`
120 | 
121 | What about `export` declarations? One option would be to transform them into
122 | CommonJS code that updates the `exports` object, since interoperability
123 | with Node and CommonJS is certainly a goal of this approach.
124 | 
125 | However, if `Module.prototype.link` takes an `id` string and a map of
126 | *setter* functions, then it seems natural for `Module.prototype.export` to
127 | be method that registers *getter* functions. Given these getter functions,
128 | whenever `module.link(id, ...)` is called by a parent module, the getters
129 | for the `id` module will run, updating its `module.exports` object, so
130 | that the `module.link` method has access to the latest exported values.
131 | 
132 | The `module.export` method is called with a single object literal whose
133 | keys are exported symbol names and whose values are getter functions for
134 | those exported symbols. So, for example,
135 | 
136 | ```js
137 | export const a = "a", b = "b", ...;
138 | ```
139 | 
140 | becomes
141 | 
142 | ```js
143 | module.export({
144 |   a: () => a,
145 |   b: () => b,
146 |   ...
147 | });
148 | const a = "a", b = "b", ...;
149 | ```
150 | 
151 | This code registers getter functions for the variables `a`, `b`, ..., so
152 | that `module.link` can easily retrieve the latest values of those
153 | variables at any time. It's important that we register getter functions
154 | rather than storing computed values, so that other modules always can
155 | import the newest values.
156 | 
157 | Export remapping works, too:
158 | 
159 | ```js
160 | let c = 123;
161 | export { c as see }
162 | ```
163 | 
164 | becomes
165 | 
166 | ```js
167 | module.export({ see: () => c });
168 | let c = 123;
169 | ```
170 | 
171 | Note that the `module.export` call is "hoisted" to the top of the block
172 | where it appears. This is safe because the getter functions work equally
173 | well anywhere in the scope where the exported variable is declared, and
174 | a good idea because the hoisting ensures the getters are registered as
175 | early as possible.
176 | 
177 | What about `export default <expression>` declarations? It would be a
178 | mistake to defer evaluation of the `default` expression until later, so
179 | wrapping it in a hoisted getter function is not exactly what we want.
180 | 
181 | Instead,
182 | 
183 | ```js
184 | export default computeDefault();
185 | ```
186 | 
187 | gets replaced where it is (without any hoisting) by
188 | 
189 | ```js
190 | module.exportDefault(computeDefault());
191 | ```
192 | 
193 | The `module.exportDefault` method is just a convenient
194 | [wrapper](https://github.com/benjamn/reify/blob/d7c27163a77dac184979862f808ef4e88de91ba8/lib/runtime/index.js#L60-L67)
195 | around `module.export`:
196 | 
197 | ```js
198 | module.exportDefault = function (value) {
199 |   return this.export({
200 |     default: function () {
201 |       return value;
202 |     }
203 |   }, true);
204 | };
205 | ```
206 | 
207 | That `true` argument we're passing to `module.export` is a hint that the
208 | value returned by this getter function will never change, which enables
209 | [some optimizations](https://github.com/benjamn/reify/issues/134) behind
210 | the scenes.
211 | 
212 | ### `module.runSetters()`
213 | 
214 | Now, suppose you change the value of an exported local variable after the
215 | module has finished loading. Then you need to let the module system know
216 | about the update, and that's where `module.runSetters` comes in. The
217 | module system calls this method on your behalf whenever a module finishes
218 | loading, but you can also call it manually, or simply let `reify` generate
219 | code that calls `module.runSetters` for you whenever you assign to an
220 | exported local variable.
221 | 
222 | Calling `module.runSetters()` with no arguments causes any setters that
223 | depend on the current module to be rerun, *but only if the value a setter
224 | would receive is different from the last value passed to the setter*.
225 | 
226 | If you pass an argument to `module.runSetters`, the value of that argument
227 | will be returned as-is, so that you can easily wrap assignment expressions
228 | with calls to `module.runSetters`:
229 | 
230 | ```js
231 | export let value = 0;
232 | export function increment(by) {
233 |   return value += by;
234 | };
235 | ```
236 | 
237 | should become
238 | 
239 | ```js
240 | module.export({
241 |   value: () => value,
242 |   increment: () => increment,
243 | });
244 | let value = 0;
245 | function increment(by) {
246 |   return module.runSetters(value += by);
247 | };
248 | ```
249 | 
250 | Note that `module.runSetters(argument)` does not actually use `argument`.
251 | However, by having `module.runSetters(argument)` return `argument`
252 | unmodified, we can run setters immediately after the assignment without
253 | interfering with evaluation of the larger expression.
254 | 
255 | Because `module.runSetters` runs any setters that have new values, it's
256 | also useful for potentially risky expressions that are difficult to
257 | analyze statically:
258 | 
259 | ```js
260 | export let value = 0;
261 | 
262 | function runCommand(command) {
263 |   // This picks up any new values of any exported local variables that may
264 |   // have been modified by eval.
265 |   return module.runSetters(eval(command));
266 | }
267 | 
268 | runCommand("value = 1234");
269 | ```
270 | 
271 | ### `export`s that are really `import`s
272 | 
273 | What about `export ... from "./module"` declarations? The key insight here
274 | is that **`export` declarations with a `from "..."` clause are really just
275 | `import` declarations that update the `exports` object instead of updating
276 | local variables**:
277 | 
278 | ```js
279 | export { a, b as c } from "./module";
280 | ```
281 | becomes
282 | ```js
283 | module.link("./module", {
284 |   a(value) { exports.a = value; },
285 |   b(value) { exports.c = value; },
286 | });
287 | ```
288 | 
289 | Since this pattern is so common, and no local variables need to be
290 | modified by these setter functions, the runtime API supports an
291 | alternative shorthand for re-exporting values:
292 | 
293 | ```js
294 | module.link("./module", { a: "a", b: "c" });
295 | ```
296 | 
297 | This strategy cleanly generalizes to `export * from "..."` declarations:
298 | 
299 | ```js
300 | export * from "./module";
301 | ```
302 | becomes
303 | ```js
304 | module.link("./module", {
305 |   "*"(ns) {
306 |     Object.assign(exports, ns);
307 |   }
308 | });
309 | ```
310 | 
311 | Though the basic principle is the same, in reality the Reify compiler
312 | generates shorthand notation for this pattern as well:
313 | 
314 | ```js
315 | module.link("./module", { "*": "*" });
316 | ```
317 | 
318 | This version is shorter, does not rely on `Object.assign` (or a polyfill),
319 | can be a little smarter about copying special properties such as getters,
320 | and reliably modifies `module.exports` instead of the `exports` variable
321 | (whatever it may be). Win!
322 | 
323 | Exporting named namespaces ([proposal](https://github.com/leebyron/ecmascript-export-ns-from)):
324 | ```js
325 | export * as ns from "./module";
326 | ```
327 | becomes
328 | ```js
329 | module.link("./module", {
330 |   "*"(ns) { exports.ns = ns; }
331 | });
332 | ```
333 | 
334 | Shorthand:
335 | 
336 | ```js
337 | module.link("./module", { "*": "ns" });
338 | ```
339 | 
340 | Re-exporting default exports ([proposal](https://github.com/leebyron/ecmascript-export-default-from)):
341 | ```js
342 | export a, { b, c as d } from "./module";
343 | ```
344 | becomes
345 | ```js
346 | module.link("./module", {
347 |   default(value) { exports.a = value; },
348 |   b(value) { exports.b = value; },
349 |   c(value) { exports.d = value; }
350 | });
351 | ```
352 | 
353 | Shorthand:
354 | 
355 | ```js
356 | module.link("./module", {
357 |   default: "a",
358 |   b: "b",
359 |   c: "d"
360 | });
361 | ```
362 | 
363 | While these examples have not covered every possible syntax for `import`
364 | and `export` declarations, I hope they provide the intuition necessary to
365 | imagine how any declaration could be compiled.
366 | 
367 | When I have some time, I hope to implement a [live-compiling text
368 | editor](https://github.com/benjamn/reify/issues/15) to enable
369 | experimentation.
370 | 


--------------------------------------------------------------------------------
/examples/babel-parser-example/README.md:
--------------------------------------------------------------------------------
 1 | # `babel-parser-example`
 2 | 
 3 | Example package using `@babel/parser` instead of the default Acorn parser.
 4 | 
 5 | ## Installation
 6 | 
 7 | ```sh
 8 | cd packages/babel-parser-example
 9 | npm install
10 | ```
11 | 
12 | ## Usage
13 | 
14 | ```js
15 | > require("./index.js")
16 | { __esModule: true, name: "module.js" }
17 | ```
18 | 
19 | 


--------------------------------------------------------------------------------
/examples/babel-parser-example/index.js:
--------------------------------------------------------------------------------
1 | require("reify/node");
2 | module.exports = require("./module.js");
3 | 


--------------------------------------------------------------------------------
/examples/babel-parser-example/module.js:
--------------------------------------------------------------------------------
1 | import { basename } from "path";
2 | export var name = basename(module.id);
3 | 


--------------------------------------------------------------------------------
/examples/babel-parser-example/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "babel-parser-example",
 3 |   "version": "0.1.0",
 4 |   "lockfileVersion": 1,
 5 |   "requires": true,
 6 |   "dependencies": {
 7 |     "acorn": {
 8 |       "version": "5.7.3",
 9 |       "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.3.tgz",
10 |       "integrity": "sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw=="
11 |     },
12 |     "reify": {
13 |       "version": "0.18.1",
14 |       "resolved": "https://registry.npmjs.org/reify/-/reify-0.18.1.tgz",
15 |       "integrity": "sha512-eNiNGxo5Cz/s/7DOeQW5+lTAxMexZPFA8XW/ef6f8WBLtQfYAhDNXxva7ROFC/Wa3q91usYzqJYwC85OXaWUzA==",
16 |       "requires": {
17 |         "acorn": "^5.5.3",
18 |         "semver": "^5.4.1"
19 |       }
20 |     },
21 |     "semver": {
22 |       "version": "5.6.0",
23 |       "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
24 |       "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg=="
25 |     }
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/examples/babel-parser-example/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "babel-parser-example",
 3 |   "author": "Ben Newman <ben@benjamn.com>",
 4 |   "version": "0.1.0",
 5 |   "description": "Example of using Reify with @babel/parser.",
 6 |   "private": true,
 7 |   "main": "index.js",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "https://github.com/benjamn/reify/tree/main/packages/babel-parser-example"
11 |   },
12 |   "keywords": [
13 |     "reify",
14 |     "example",
15 |     "acorn",
16 |     "parser",
17 |     "modules",
18 |     "import",
19 |     "export",
20 |     "compiler"
21 |   ],
22 |   "license": "MIT",
23 |   "engines": {
24 |     "node": ">=4"
25 |   },
26 |   "dependencies": {
27 |     "reify": "^0.18.1"
28 |   },
29 |   "reify": {
30 |     "parser": "reify/lib/parsers/babel.js"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/examples/custom-cache-example/README.md:
--------------------------------------------------------------------------------
 1 | # `custom-cache-example`
 2 | 
 3 | Example package using a different cache directory than the default:
 4 | `packages/custom-cache-example/.reify-custom-cache` instead of
 5 | `.reify-cache`.
 6 | 
 7 | ## Installation
 8 | 
 9 | ```sh
10 | cd packages/babel-parser-example
11 | npm install
12 | ```
13 | 
14 | ## Usage
15 | 
16 | ```js
17 | > require("./index.js")
18 | { __esModule: true, name: "module.js" }
19 | > .exit
20 | ```
21 | 
22 | then
23 | 
24 | ```sh
25 | % ls .reify-custom-cache
26 | a2f2d6b8b16ddbc496993cb55f3621f5fe4e5f1a.json
27 | 
28 | % cat .reify-custom-cache/a2f2d6b8b16ddbc496993cb55f3621f5fe4e5f1a.json
29 | module.export({name:function(){return name}});var basename;module.import("path",{"basename":function(v){basename=v}},0);
30 | var name = basename(module.id);
31 | ```
32 | 


--------------------------------------------------------------------------------
/examples/custom-cache-example/index.js:
--------------------------------------------------------------------------------
1 | require("reify/node");
2 | module.exports = require("./module.js");
3 | 


--------------------------------------------------------------------------------
/examples/custom-cache-example/module.js:
--------------------------------------------------------------------------------
1 | import { basename } from "path";
2 | export var name = basename(module.id);
3 | 


--------------------------------------------------------------------------------
/examples/custom-cache-example/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "custom-cache-example",
 3 |   "author": "Ben Newman <ben@benjamn.com>",
 4 |   "version": "0.1.0",
 5 |   "description": "Example of using Reify with a custom cache directory.",
 6 |   "private": true,
 7 |   "main": "index.js",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "https://github.com/benjamn/reify/tree/main/packages/custom-cache-example"
11 |   },
12 |   "keywords": [
13 |     "reify",
14 |     "example",
15 |     "acorn",
16 |     "parser",
17 |     "modules",
18 |     "import",
19 |     "export",
20 |     "compiler"
21 |   ],
22 |   "license": "MIT",
23 |   "engines": {
24 |     "node": ">=4"
25 |   },
26 |   "dependencies": {
27 |     "reify": "^0.5.1"
28 |   },
29 |   "reify": {
30 |     "cache-directory": ".reify-custom-cache"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/examples/top-level-example/README.md:
--------------------------------------------------------------------------------
 1 | # `top-level-example`
 2 | 
 3 | Example package using the Acorn-based top-level-only parser instead of the
 4 | default Acorn parser.
 5 | 
 6 | ## Installation
 7 | 
 8 | ```sh
 9 | cd packages/top-level-example
10 | npm install
11 | ```
12 | 
13 | ## Usage
14 | 
15 | ```js
16 | > require("./index.js")
17 | { __esModule: true, name: "module.js" }
18 | ```
19 | 
20 | 


--------------------------------------------------------------------------------
/examples/top-level-example/index.js:
--------------------------------------------------------------------------------
1 | require("reify/node");
2 | module.exports = require("./module.js");
3 | 


--------------------------------------------------------------------------------
/examples/top-level-example/module.js:
--------------------------------------------------------------------------------
1 | import { basename } from "path";
2 | export var name = basename(module.id);
3 | 


--------------------------------------------------------------------------------
/examples/top-level-example/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "top-level-example",
 3 |   "author": "Ben Newman <ben@benjamn.com>",
 4 |   "version": "0.1.0",
 5 |   "description": "Example of using Reify with a top-level parser.",
 6 |   "private": true,
 7 |   "main": "index.js",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "https://github.com/benjamn/reify/tree/main/packages/top-level-example"
11 |   },
12 |   "keywords": [
13 |     "reify",
14 |     "example",
15 |     "acorn",
16 |     "parser",
17 |     "modules",
18 |     "import",
19 |     "export",
20 |     "compiler"
21 |   ],
22 |   "license": "MIT",
23 |   "engines": {
24 |     "node": ">=4"
25 |   },
26 |   "dependencies": {
27 |     "reify": "^0.5.1"
28 |   },
29 |   "reify": {
30 |     "parser": "reify/lib/parsers/top-level.js"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/lib/assignment-visitor.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const utils = require("./utils.js");
  4 | const Visitor = require("./visitor.js");
  5 | 
  6 | class AssignmentVisitor extends Visitor {
  7 |   reset(rootPath, options) {
  8 |     this.exportedLocalNames = options.exportedLocalNames;
  9 |     this.magicString = options.magicString;
 10 |     this.modifyAST = !! options.modifyAST;
 11 |     this.moduleAlias = options.moduleAlias;
 12 | 
 13 |     if (this.exportedLocalNames === void 0) {
 14 |       this.exportedLocalNames = Object.create(null);
 15 |     }
 16 | 
 17 |     if (this.magicString === void 0) {
 18 |       this.magicString = null;
 19 |     }
 20 | 
 21 |     if (this.magicString) {
 22 |       const identifiers = Object.keys(this.exportedLocalNames);
 23 | 
 24 |       // In addition to any exported local identifiers, this visitor needs
 25 |       // to visit `eval(...)` expressions, so it's important to search for
 26 |       // any possible indexes of the `eval` identifier, too.
 27 |       identifiers.push("eval");
 28 | 
 29 |       // When this.possibleIndexes is defined, the AST traversal can
 30 |       // abandon any subtrees that do not contain any possible indexes.
 31 |       this.possibleIndexes = utils.findLikelyIndexes(
 32 |         this.magicString.original,
 33 |         identifiers
 34 |       );
 35 |     }
 36 |   }
 37 | 
 38 |   visitAssignmentExpression(path) {
 39 |     return assignmentHelper(this, path, "left");
 40 |   }
 41 | 
 42 |   visitCallExpression(path) {
 43 |     const callee = path.getValue().callee;
 44 | 
 45 |     if (callee.type === "MemberExpression" &&
 46 |         isId(callee.object, this.moduleAlias) &&
 47 |         isId(callee.property, "runSetters")) {
 48 |       // If we've already wrapped this subtree, abandon it.
 49 |       return false;
 50 |     }
 51 | 
 52 |     this.visitChildren(path);
 53 | 
 54 |     if (isId(callee, "eval")) {
 55 |       wrap(this, path);
 56 |     }
 57 |   }
 58 | 
 59 |   visitUpdateExpression(path) {
 60 |     return assignmentHelper(this, path, "argument");
 61 |   }
 62 | };
 63 | 
 64 | function isId(node, name) {
 65 |   if (!node || node.type !== "Identifier") {
 66 |     return false;
 67 |   }
 68 | 
 69 |   if (name) {
 70 |     return node.name === name;
 71 |   }
 72 | 
 73 |   return true;
 74 | }
 75 | 
 76 | function assignmentHelper(visitor, path, childName) {
 77 |   visitor.visitChildren(path);
 78 | 
 79 |   const child = path.getValue()[childName];
 80 |   const assignedNames = utils.getNamesFromPattern(child);
 81 |   const nameCount = assignedNames.length;
 82 | 
 83 |   // Wrap assignments to exported identifiers with `module.runSetters`.
 84 |   for (let i = 0; i < nameCount; ++i) {
 85 |     if (visitor.exportedLocalNames[assignedNames[i]] === true) {
 86 |       wrap(visitor, path);
 87 |       break;
 88 |     }
 89 |   }
 90 | }
 91 | 
 92 | function wrap(visitor, path) {
 93 |   const value = path.getValue();
 94 | 
 95 |   if (visitor.magicString !== null) {
 96 |     visitor.magicString.prependRight(
 97 |       value.start,
 98 |       visitor.moduleAlias + ".runSetters("
 99 |     ).appendLeft(value.end, ")");
100 |   }
101 | 
102 |   if (visitor.modifyAST) {
103 |     path.replace({
104 |       type: "CallExpression",
105 |       callee: {
106 |         type: "MemberExpression",
107 |         object: {
108 |           type: "Identifier",
109 |           name: visitor.moduleAlias,
110 |         },
111 |         property: {
112 |           type: "Identifier",
113 |           name: "runSetters"
114 |         }
115 |       },
116 |       arguments: [value]
117 |     });
118 |   }
119 | }
120 | 
121 | module.exports = AssignmentVisitor;
122 | 


--------------------------------------------------------------------------------
/lib/compiler.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const dynRequire = module.require ? module.require.bind(module) : __non_webpack_require__;
  4 | const getOption = require("./options.js").get;
  5 | 
  6 | const AV = require("./assignment-visitor.js");
  7 | const FastPath = require("./fast-path.js");
  8 | const IEV = require("./import-export-visitor.js");
  9 | 
 10 | const assignmentVisitor = new AV;
 11 | const importExportVisitor = new IEV;
 12 | 
 13 | const codeOfPound = "#".charCodeAt(0);
 14 | const shebangRegExp = /^#!.*/;
 15 | 
 16 | const utils = require("./utils.js");
 17 | 
 18 | exports.compile = function (code, options) {
 19 |   options = Object.assign(Object.create(null), options);
 20 | 
 21 |   if (code.charCodeAt(0) === codeOfPound) {
 22 |     code = code.replace(shebangRegExp, "");
 23 |   }
 24 | 
 25 |   const result = {
 26 |     code,
 27 |     ast: null,
 28 |     identical: false
 29 |   };
 30 | 
 31 |   // Quickly scan the code to find all possible indexes of import or
 32 |   // export keywords, tolerating some false positives.
 33 |   options.possibleIndexes =
 34 |     utils.findLikelyIndexes(code, ["import", "export"]);
 35 |   const mayHaveImportsOrExports = options.possibleIndexes.length > 0;
 36 | 
 37 |   const parse = getOption(options, "parse");
 38 |   if (getOption(options, "ast")) {
 39 |     result.ast = parse(code);
 40 |   }
 41 | 
 42 |   options.moduleAlias = getOption(options, "moduleAlias");
 43 | 
 44 |   if (
 45 |     ! mayHaveImportsOrExports &&
 46 |     options.moduleAlias === "module" &&
 47 |     getOption(options, "sourceType") !== "module"
 48 |   ) {
 49 |     // Let the caller know the result is no different from the input.
 50 |     result.identical = true;
 51 |     return result;
 52 |   }
 53 | 
 54 |   const rootPath = new FastPath(result.ast || parse(code));
 55 | 
 56 |   importExportVisitor.visit(rootPath, code, options);
 57 | 
 58 |   const magicString = importExportVisitor.magicString;
 59 |   result.identical = ! importExportVisitor.madeChanges;
 60 | 
 61 |   if (! result.identical) {
 62 |     assignmentVisitor.visit(rootPath, {
 63 |       exportedLocalNames: importExportVisitor.exportedLocalNames,
 64 |       magicString: magicString,
 65 |       modifyAST: importExportVisitor.modifyAST,
 66 |       moduleAlias: importExportVisitor.moduleAlias
 67 |     });
 68 |   }
 69 | 
 70 |   // Whether or not there were any changes, finalizeHoisting does some
 71 |   // important cleanup work, and should not be computationally expensive
 72 |   // when no changes need to be made.
 73 |   importExportVisitor.finalizeHoisting();
 74 | 
 75 |   result.code = magicString.toString();
 76 | 
 77 |   return result;
 78 | };
 79 | 
 80 | exports.transform = function (ast, options) {
 81 |   return dynRequire("./transform.js")(ast, options);
 82 | };
 83 | 
 84 | function makeUniqueId(prefix, source) {
 85 |   const scanRegExp = new RegExp("\\b" + prefix + "(\\d*)\\b", "g");
 86 |   let match, max = -1;
 87 | 
 88 |   while ((match = scanRegExp.exec(source))) {
 89 |     max = Math.max(max, +(match[1] || 0));
 90 |   }
 91 | 
 92 |   if (max >= 0) {
 93 |     return prefix + (max + 1);
 94 |   }
 95 | 
 96 |   return prefix;
 97 | }
 98 | 
 99 | exports.makeUniqueId = makeUniqueId;
100 | 


--------------------------------------------------------------------------------
/lib/empty.js:
--------------------------------------------------------------------------------
1 | // The "reify" package is only intended to work in Node.
2 | 


--------------------------------------------------------------------------------
/lib/fast-object.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | let fastProto = null;
 4 | 
 5 | // Creates an object with permanently fast properties in V8. See Toon Verwaest's
 6 | // post https://medium.com/@tverwaes/setting-up-prototypes-in-v8-ec9c9491dfe2#5f62
 7 | // for more details. Use %HasFastProperties(object) and the Node flag
 8 | // --allow-natives-syntax to check whether an object has fast properties.
 9 | function FastObject() {
10 |   // A prototype object will have "fast properties" enabled once it is checked
11 |   // against the inline property cache of a function, e.g. fastProto.property:
12 |   // https://github.com/v8/v8/blob/6.0.122/test/mjsunit/fast-prototype.js#L48-L63
13 |   if (fastProto !== null && typeof fastProto.property) {
14 |     const result = fastProto;
15 |     fastProto = FastObject.prototype = null;
16 |     return result;
17 |   }
18 |   fastProto = FastObject.prototype = Object.create(null);
19 |   return new FastObject;
20 | }
21 | 
22 | // Initialize the inline property cache of FastObject.
23 | FastObject();
24 | 
25 | module.exports = FastObject;
26 | 


--------------------------------------------------------------------------------
/lib/fast-path.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | // A simplified version of the AST traversal abstraction used by Recast:
  4 | // https://github.com/benjamn/recast/blob/master/lib/fast-path.js
  5 | 
  6 | const assert = require("assert");
  7 | const utils = require("./utils.js");
  8 | const brandKey = "reify-fast-path";
  9 | const brand = typeof Symbol === "function"
 10 |   ? Symbol.for(brandKey)
 11 |   : brandKey;
 12 | 
 13 | class FastPath {
 14 |   constructor(ast) {
 15 |     assert.notStrictEqual(ast, null);
 16 |     assert.strictEqual(typeof ast, "object");
 17 |     this.stack = [ast];
 18 |   }
 19 | 
 20 |   static isInstance(value) {
 21 |     return value !== null &&
 22 |       typeof value === "object" &&
 23 |       value[brand] === true;
 24 |   }
 25 | 
 26 |   static from(value) {
 27 |     return this.isInstance(value) ? value : new this(value);
 28 |   }
 29 | 
 30 |   // Temporarily push properties named by string arguments given after the
 31 |   // callback function onto this.stack, then call the callback with a
 32 |   // reference to this (modified) FastPath object. Note that the stack will
 33 |   // be restored to its original state after the callback is finished, so it
 34 |   // is probably a mistake to retain a reference to the path.
 35 |   call(callback/*, name1, name2, ... */) {
 36 |     const s = this.stack;
 37 |     const origLen = s.length;
 38 |     const argCount = arguments.length;
 39 |     let value = s[origLen - 1];
 40 | 
 41 |     for (let i = 1; i < argCount; ++i) {
 42 |       const name = arguments[i];
 43 |       value = value[name];
 44 |       s.push(name, value);
 45 |     }
 46 |     const result = callback(this);
 47 |     s.length = origLen;
 48 | 
 49 |     return result;
 50 |   }
 51 | 
 52 |   // Similar to FastPath.prototype.call, except that the value obtained by
 53 |   // accessing this.getValue()[name1][name2]... should be array-like. The
 54 |   // callback will be called with a reference to this path object for each
 55 |   // element of the array.
 56 |   each(callback/*, name1, name2, ... */) {
 57 |     const s = this.stack;
 58 |     const origLen = s.length;
 59 |     const argCount = arguments.length;
 60 |     let value = s[origLen - 1];
 61 | 
 62 |     for (let i = 1; i < argCount; ++i) {
 63 |       const name = arguments[i];
 64 |       value = value[name];
 65 |       s.push(name, value);
 66 |     }
 67 | 
 68 |     for (let i = 0; i < value.length; ++i) {
 69 |       s.push(i, value[i]);
 70 |       // If the callback needs to know the value of i, call path.getName(),
 71 |       // assuming path is the parameter name.
 72 |       callback(this);
 73 |       s.length -= 2;
 74 |     }
 75 | 
 76 |     s.length = origLen;
 77 |   }
 78 | 
 79 |   getContainer() {
 80 |     return getStackAt(this, 3);
 81 |   }
 82 | 
 83 |   getName() {
 84 |     // The name of the current property is always the penultimate element of
 85 |     // this.stack, and always a String. Since the name is always a string,
 86 |     // null is a safe sentinel value to return if we do not know the name of
 87 |     // the (root) value.
 88 |     return getStackAt(this, 2);
 89 |   }
 90 | 
 91 |   getNode() {
 92 |     return getNodeAt(this, 0);
 93 |   }
 94 | 
 95 |   getParentNode() {
 96 |     return getNodeAt(this, 1);
 97 |   }
 98 | 
 99 |   getValue() {
100 |     // The value of the current property is always the last element of
101 |     // this.stack.
102 |     return getStackAt(this, 1);
103 |   }
104 | 
105 |   replace(newValue) {
106 |     const s = this.stack;
107 |     const len = s.length;
108 |     const oldValue = this.getValue();
109 | 
110 |     if (len > 2) {
111 |       const parent = s[len - 3];
112 |       const name = this.getName();
113 |       parent[name] = s[len - 1] = newValue;
114 |     }
115 |     return oldValue;
116 |   }
117 | 
118 |   valueIsNode() {
119 |     return utils.isNodeLike(this.getValue());
120 |   }
121 | };
122 | 
123 | Object.setPrototypeOf(FastPath.prototype, null);
124 | 
125 | Object.defineProperty(FastPath.prototype, brand, {
126 |   value: true,
127 |   enumerable: false,
128 |   writable: false,
129 |   configurable: false
130 | });
131 | 
132 | function getNodeAt(path, pos) {
133 |   const s = path.stack;
134 | 
135 |   for (let i = s.length - 1; i >= 0; i -= 2) {
136 |     const value = s[i];
137 |     if (utils.isNodeLike(value) && --pos < 0) {
138 |       return value;
139 |     }
140 |   }
141 |   return null;
142 | }
143 | 
144 | function getStackAt(path, pos) {
145 |   const s = path.stack;
146 |   const len = s.length;
147 |   return len < pos ? null : s[len - pos];
148 | }
149 | 
150 | module.exports = FastPath;
151 | 


--------------------------------------------------------------------------------
/lib/options.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const hasOwn = Object.prototype.hasOwnProperty;
 4 | const defaultParser = require("./parsers/default.js");
 5 | const defaultOptions = {
 6 |   ast: false,
 7 |   // If not false, "use strict" will be added to any modules with at least
 8 |   // one import or export declaration.
 9 |   enforceStrictMode: true,
10 |   generateLetDeclarations: false,
11 |   avoidModernSyntax: false,
12 |   sourceType: "unambiguous",
13 |   moduleAlias: "module",
14 |   dynamicImport: false,
15 |   // Controls whether finalizeHoisting performs one-time-only transforms like
16 |   // wrapping the module body in a function.
17 |   finalCompilationPass: true,
18 |   parse(code) {
19 |     return defaultParser.parse(code);
20 |   }
21 | };
22 | 
23 | function get(options, name) {
24 |   const result = hasOwn.call(options, name) ? options[name] : void 0;
25 |   return result === void 0 ? defaultOptions[name] : result;
26 | }
27 | 
28 | exports.get = get;
29 | 
30 | function setDefaults(options) {
31 |   Object.assign(defaultOptions, options);
32 | }
33 | 
34 | exports.setDefaults = setDefaults;
35 | 


--------------------------------------------------------------------------------
/lib/parsers/acorn-extensions/export.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const acorn = require("acorn");
  4 | const utils = require("../../utils.js");
  5 | 
  6 | const Pp = acorn.Parser.prototype;
  7 | const tt = acorn.tokTypes;
  8 | 
  9 | exports.enable = function (parser) {
 10 |   parser.parseExport = parseExport;
 11 |   parser.parseExportSpecifiers = parseExportSpecifiers;
 12 | };
 13 | 
 14 | function parseExport(node, exported) {
 15 |   // export ...
 16 |   this.next();
 17 | 
 18 |   if (this.type === tt._default) {
 19 |     // ... default function|class|=...;
 20 |     return parseExportDefaultDeclaration(this, node, exported);
 21 |   }
 22 | 
 23 |   if (this.type === tt.star &&
 24 |       utils.lookahead(this).isContextual("from")) {
 25 |     // ... * from "...";
 26 |     return parseExportNamespace(this, node);
 27 |   }
 28 | 
 29 |   if (this.shouldParseExportStatement()) {
 30 |     // ... var|const|let|function|class ...
 31 |     return parseExportNamedDeclaration(this, node, exported);
 32 |   }
 33 | 
 34 |   // ... def, [, * as ns [, { x, y as z }]] from "...";
 35 |   node.specifiers = this.parseExportSpecifiers(exported);
 36 | 
 37 |   if (this.isContextual("from")) {
 38 |     parseExportFrom(this, node);
 39 |   } else {
 40 |     this.semicolon();
 41 |   }
 42 | 
 43 |   return this.finishNode(node, "ExportNamedDeclaration");
 44 | }
 45 | 
 46 | function parseExportSpecifiers(exported) {
 47 |   let expectFrom = false;
 48 |   const specifiers = [];
 49 | 
 50 |   do {
 51 |     if (this.type === tt.name) {
 52 |       // ... def [, ...]
 53 |       expectFrom = true;
 54 |       specifiers.push(parseExportDefaultSpecifier(this));
 55 |     } else if (this.type === tt.star) {
 56 |       // ... * as ns [, ...]
 57 |       expectFrom = true;
 58 |       specifiers.push(parseExportNamespaceSpecifier(this, exported));
 59 |     } else if (this.type === tt.braceL) {
 60 |       // ... { x, y as z } [, ...]
 61 |       specifiers.push.apply(specifiers, Pp.parseExportSpecifiers.call(this, exported));
 62 |     }
 63 |   }
 64 |   while (this.eat(tt.comma));
 65 | 
 66 |   if (expectFrom && ! this.isContextual("from")) {
 67 |     this.unexpected();
 68 |   }
 69 | 
 70 |   return specifiers;
 71 | }
 72 | 
 73 | function parseExportDefaultDeclaration(parser, node, exported) {
 74 |   // ... default function|class|=...;
 75 |   exported.default = true;
 76 |   parser.next();
 77 | 
 78 |   let isAsync;
 79 |   if (parser.type === tt._function || (isAsync = parser.isAsyncFunction())) {
 80 |     // Parse a function declaration.
 81 |     const funcNode = parser.startNode();
 82 |     if (isAsync) {
 83 |       parser.next();
 84 |     }
 85 |     parser.next();
 86 |     node.declaration = parser.parseFunction(funcNode, "nullableID", false, isAsync);
 87 |   } else if (parser.type === tt._class) {
 88 |     // Parse a class declaration.
 89 |     node.declaration = parser.parseClass(parser.startNode(), "nullableID");
 90 |   } else {
 91 |     // Parse an assignment expression.
 92 |     node.declaration = parser.parseMaybeAssign();
 93 |   }
 94 | 
 95 |   parser.semicolon();
 96 |   return parser.finishNode(node, "ExportDefaultDeclaration");
 97 | }
 98 | 
 99 | function parseExportDefaultSpecifier(parser) {
100 |   // ... def
101 |   const specifier = parser.startNode();
102 |   specifier.exported = parser.parseIdent();
103 |   return parser.finishNode(specifier, "ExportDefaultSpecifier");
104 | }
105 | 
106 | function parseExportFrom(parser, node) {
107 |   // ... from "...";
108 |   parser.expectContextual("from");
109 |   node.source = parser.type === tt.string ? parser.parseExprAtom() : null;
110 |   parser.semicolon();
111 | }
112 | 
113 | function parseExportNamedDeclaration(parser, node, exported) {
114 |   // ... var|const|let|function|class ...
115 |   node.declaration = parser.parseStatement(null);
116 |   node.source = null;
117 |   node.specifiers = [];
118 | 
119 |   if (node.declaration.type === "VariableDeclaration") {
120 |     parser.checkVariableExport(exported, node.declaration.declarations);
121 |   } else {
122 |     exported[node.declaration.id.name] = true;
123 |   }
124 | 
125 |   return parser.finishNode(node, "ExportNamedDeclaration");
126 | }
127 | 
128 | function parseExportNamespace(parser, node) {
129 |   // ... * from "...";
130 |   parser.next();
131 |   node.specifiers = [];
132 |   parseExportFrom(parser, node);
133 |   return parser.finishNode(node, "ExportAllDeclaration");
134 | }
135 | 
136 | function parseExportNamespaceSpecifier(parser, exported) {
137 |   // ... * as ns
138 |   const star = parser.startNode();
139 |   parser.next();
140 |   parser.expectContextual("as");
141 |   star.exported = parser.parseIdent();
142 |   exported[star.exported.name] = true;
143 |   return parser.finishNode(star, "ExportNamespaceSpecifier");
144 | }
145 | 


--------------------------------------------------------------------------------
/lib/parsers/acorn-extensions/import.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const acorn = require("acorn");
 4 | 
 5 | const Pp = acorn.Parser.prototype;
 6 | const tt = acorn.tokTypes;
 7 | 
 8 | exports.enable = function (parser) {
 9 |   parser.parseImportSpecifiers = parseImportSpecifiers;
10 | };
11 | 
12 | function parseImportSpecifiers() {
13 |   const specifiers = [];
14 | 
15 |   do {
16 |     if (this.type === tt.name) {
17 |       // ... def [, ...]
18 |       specifiers.push(parseImportDefaultSpecifier(this));
19 |     } else if (this.type === tt.star) {
20 |       // ... * as ns [, ...]
21 |       specifiers.push(parseImportNamespaceSpecifier(this));
22 |     } else if (this.type === tt.braceL) {
23 |       // ... { x, y as z } [, ...]
24 |       specifiers.push.apply(specifiers, Pp.parseImportSpecifiers.call(this));
25 |     }
26 |   }
27 |   while (this.eat(tt.comma));
28 | 
29 |   return specifiers;
30 | }
31 | 
32 | function parseImportDefaultSpecifier(parser) {
33 |   // ... def
34 |   const specifier = parser.startNode();
35 |   specifier.local = parser.parseIdent();
36 |   return parser.finishNode(specifier, "ImportDefaultSpecifier");
37 | }
38 | 
39 | function parseImportNamespaceSpecifier(parser) {
40 |   // ... * as ns
41 |   const star = parser.startNode();
42 |   parser.next();
43 |   parser.expectContextual("as");
44 |   star.local = parser.parseIdent();
45 |   return parser.finishNode(star, "ImportNamespaceSpecifier");
46 | }
47 | 


--------------------------------------------------------------------------------
/lib/parsers/acorn-extensions/index.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | exports.enableAll = function (parser) {
 4 |   Object.keys(exports).forEach((key) => {
 5 |     if (key !== "enableAll") {
 6 |       exports[key](parser);
 7 |     }
 8 |   });
 9 | };
10 | 
11 | exports.enableExportExtensions = require("./export.js").enable;
12 | exports.enableImportExtensions = require("./import.js").enable;
13 | exports.enableTolerance = require("./tolerance.js").enable;
14 | 


--------------------------------------------------------------------------------
/lib/parsers/acorn-extensions/tolerance.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | exports.enable = function (parser) {
 4 |   // It's not Reify's job to enforce strictness.
 5 |   parser.strict = false;
 6 |   // Tolerate recoverable parse errors.
 7 |   parser.raiseRecoverable = noopRaiseRecoverable;
 8 | };
 9 | 
10 | function noopRaiseRecoverable() {}
11 | 


--------------------------------------------------------------------------------
/lib/parsers/acorn.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const Parser = require("acorn").Parser.extend(
 4 |   require("acorn-dynamic-import").default
 5 | );
 6 | 
 7 | const acornExtensions = require("./acorn-extensions");
 8 | 
 9 | exports.options = {
10 |   allowHashBang: true,
11 |   allowImportExportEverywhere: true,
12 |   allowReturnOutsideFunction: true,
13 |   ecmaVersion: 9,
14 |   sourceType: "module"
15 | };
16 | 
17 | function parse(code) {
18 |   const parser = new Parser(exports.options, code);
19 |   acornExtensions.enableAll(parser);
20 |   return parser.parse();
21 | }
22 | 
23 | exports.parse = parse;
24 | 


--------------------------------------------------------------------------------
/lib/parsers/babel.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const babelParser = require("@babel/parser");
 4 | const babelParserVersion = require("@babel/parser/package.json").version;
 5 | 
 6 | exports.options = {
 7 |   allowImportExportEverywhere: true,
 8 |   allowReturnOutsideFunction: true,
 9 |   allowUndeclaredExports: true,
10 |   plugins: [
11 |     "*", "flow", "jsx",
12 |     // The "*" glob no longer seems to include the following plugins:
13 |     "asyncGenerators",
14 |     "bigInt",
15 |     "classPrivateMethods",
16 |     "classPrivateProperties",
17 |     "classProperties",
18 |     // Since the "decorators" plugin cannot be used together with the
19 |     // "decorators-legacy" plugin, and one of them must be used if the
20 |     // @babel/plugin-proposal-decorators Babel plugin is used, it's not
21 |     // safe to blindly include the "decorators" plugin here.
22 |     // "decorators",
23 |     "doExpressions",
24 |     "dynamicImport",
25 |     "exportDefaultFrom",
26 |     "exportExtensions",
27 |     "exportNamespaceFrom",
28 |     "functionBind",
29 |     "functionSent",
30 |     "importMeta",
31 |     "nullishCoalescingOperator",
32 |     "numericSeparator",
33 |     "objectRestSpread",
34 |     "optionalCatchBinding",
35 |     "optionalChaining",
36 |     // https://github.com/babel/babel/pull/8196
37 |     ["pipelineOperator", {
38 |       proposal: "minimal"
39 |     }],
40 |     "throwExpressions",
41 |     // Other experimental plugins that we could enable:
42 |     // https://babeljs.io/docs/en/next/babel-parser.html#plugins
43 |   ],
44 |   sourceType: "module",
45 |   strictMode: false
46 | };
47 | 
48 | function parse(code) {
49 |   return babelParser.parse(code, exports.options);
50 | }
51 | 
52 | function tolerantParse(code) {
53 |   const arrayFrom = Array.from;
54 |   // There is only one use of Array.from in the @babel/parser@7.4.x code,
55 |   // Array.from(this.scope.undefinedExports), which determines whether the
56 |   // parser complains prematurely about exporting identifiers that were
57 |   // not declared in the current module scope. By returning an empty array
58 |   // when the source argument is a Map, we can effectively disable that
59 |   // error behavior, until https://github.com/babel/babel/pull/9864 is
60 |   // released in @babel/parser@7.5.0.
61 |   Array.from = function (source) {
62 |     return source instanceof Map ? [] :
63 |       arrayFrom.apply(this, arguments);
64 |   };
65 |   try {
66 |     return parse(code);
67 |   } finally {
68 |     Array.from = arrayFrom;
69 |   }
70 | }
71 | 
72 | exports.parse = babelParserVersion.startsWith("7.4.") ? tolerantParse : parse;
73 | 


--------------------------------------------------------------------------------
/lib/parsers/babylon.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.assign(exports, require("./babel.js"));
3 | 


--------------------------------------------------------------------------------
/lib/parsers/default.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const dynRequire = module.require ? module.require.bind(module) : __non_webpack_require__;
 4 | 
 5 | const REIFY_PARSER =
 6 |   typeof process === "object" && process !== null &&
 7 |   typeof process.env === "object" && process.env !== null &&
 8 |   process.env.REIFY_PARSER;
 9 | 
10 | if (REIFY_PARSER === "acorn" ||
11 |     REIFY_PARSER === "babel" ||
12 |     REIFY_PARSER === "top-level") {
13 |   exports.parse = require("./" + process.env.REIFY_PARSER + ".js").parse;
14 | } else try {
15 |   exports.parse = dynRequire(REIFY_PARSER);
16 | } catch (e) {
17 |   exports.parse = dynRequire("./acorn.js").parse;
18 | }
19 | 


--------------------------------------------------------------------------------
/lib/parsers/top-level.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const acorn = require("acorn");
 4 | const acornExtensions = require("./acorn-extensions");
 5 | 
 6 | exports.options = {
 7 |   allowHashBang: true,
 8 |   allowImportExportEverywhere: true,
 9 |   allowReturnOutsideFunction: true,
10 |   ecmaVersion: 8,
11 |   sourceType: "module"
12 | };
13 | 
14 | function parse(code) {
15 |   const parser = new acorn.Parser(exports.options, code);
16 |   acornExtensions.enableAll(parser);
17 |   parser.parseBlock = quickParseBlock;
18 |   return parser.parse();
19 | }
20 | 
21 | // Inspired by esmod's acorn parseBlock modification.
22 | // Copyright Ingvar Stepanyan. Released under MIT license:
23 | // https://github.com/RReverser/esmod/blob/master/index.js
24 | 
25 | function quickParseBlock() {
26 |   const node = this.startNode();
27 |   const prevPos = this.context.length - 1;
28 | 
29 |   node.body = [];
30 | 
31 |   do {
32 |     this.next();
33 |   } while (this.context.length > prevPos);
34 | 
35 |   this.next();
36 |   return this.finishNode(node, "BlockStatement");
37 | }
38 | 
39 | exports.parse = parse;
40 | 


--------------------------------------------------------------------------------
/lib/runtime/entry.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | // This module should be compatible with PhantomJS v1, just like the other files
  4 | // in reify/lib/runtime. Node 4+ features like const/let and arrow functions are
  5 | // not acceptable here, and importing any npm packages should be contemplated
  6 | // with extreme skepticism.
  7 | 
  8 | var utils = require("./utils.js");
  9 | 
 10 | var GETTER_ERROR = {};
 11 | var NAN = {};
 12 | var UNDEFINED = {};
 13 | var hasOwn = Object.prototype.hasOwnProperty;
 14 | var keySalt = 0;
 15 | 
 16 | function Entry(id) {
 17 |   // The canonical absolute module ID of the module this Entry manages.
 18 |   this.id = id;
 19 | 
 20 |   // The Module object this Entry manages, unknown until module.export or
 21 |   // module.link is called for the first time.
 22 |   this.module = null;
 23 | 
 24 |   // The normalized namespace object that importers receive when they use
 25 |   // `import * as namespace from "..."` syntax.
 26 |   this.namespace = utils.createNamespace();
 27 | 
 28 |   // Getters for local variables exported from the managed module.
 29 |   this.getters = Object.create(null);
 30 | 
 31 |   // Setters for assigning to local variables in parent modules.
 32 |   this.setters = Object.create(null);
 33 | 
 34 |   // Map of setters added since the last broadcast (in the same shape as
 35 |   // entry.setters[name][key]), which should receive a broadcast the next time
 36 |   // entry.runSetters() is called, regardless of whether entry.snapshots[name]
 37 |   // has changed or not. Once called, setters are removed from this.newSetters,
 38 |   // but remain in this.setters.
 39 |   this.newSetters = Object.create(null);
 40 | 
 41 |   // Map from local names to snapshots of the corresponding local values, used
 42 |   // to determine when local values have changed and need to be re-broadcast.
 43 |   this.snapshots = Object.create(null);
 44 | }
 45 | 
 46 | var Ep = utils.setPrototypeOf(Entry.prototype, null);
 47 | var entryMap = Object.create(null);
 48 | 
 49 | Entry.getOrCreate = function (id, mod) {
 50 |   var entry = hasOwn.call(entryMap, id)
 51 |     ? entryMap[id]
 52 |     : entryMap[id] = new Entry(id);
 53 | 
 54 |   if (utils.isObject(mod) &&
 55 |       mod.id === entry.id) {
 56 |     entry.module = mod;
 57 |   }
 58 | 
 59 |   return entry;
 60 | };
 61 | 
 62 | function safeKeys(obj) {
 63 |   var keys = Object.keys(obj);
 64 |   var esModuleIndex = keys.indexOf("__esModule");
 65 |   if (esModuleIndex >= 0) {
 66 |     keys.splice(esModuleIndex, 1);
 67 |   }
 68 |   return keys;
 69 | }
 70 | 
 71 | Ep.addGetters = function (getters, constant) {
 72 |   var names = safeKeys(getters);
 73 |   var nameCount = names.length;
 74 |   constant = !! constant;
 75 | 
 76 |   for (var i = 0; i < nameCount; ++i) {
 77 |     var name = names[i];
 78 |     var getter = getters[name];
 79 | 
 80 |     if (typeof getter === "function" &&
 81 |         // Should this throw if this.getters[name] exists?
 82 |         ! (name in this.getters)) {
 83 |       this.getters[name] = getter;
 84 |       getter.constant = constant;
 85 |       getter.runCount = 0;
 86 |     }
 87 |   }
 88 | };
 89 | 
 90 | Ep.addSetters = function (parent, setters, key) {
 91 |   var names = safeKeys(setters);
 92 |   var nameCount = names.length;
 93 | 
 94 |   if (! nameCount) {
 95 |     return;
 96 |   }
 97 | 
 98 |   // If no key is provided, make a unique key. Otherwise, make sure the key is
 99 |   // distinct from keys provided by other parent modules.
100 |   key = key === void 0
101 |     ? makeUniqueKey()
102 |     : parent.id + ":" + key;
103 | 
104 |   var entry = this;
105 | 
106 |   for (var i = 0; i < nameCount; ++i) {
107 |     var name = names[i];
108 |     var setter = normalizeSetterValue(parent, setters[name]);
109 | 
110 |     if (typeof setter === "function") {
111 |       setter.parent = parent;
112 |       // Store the setter as entry.setters[name][key], and also record it
113 |       // temporarily in entry.newSetters, so we can be sure to run it when we
114 |       // call entry.runSetters(names) below, even though entry.snapshots[name]
115 |       // likely will not have changed for this name.
116 |       utils.ensureObjectProperty(entry.setters, name)[key] = setter;
117 |       utils.ensureObjectProperty(entry.newSetters, name)[key] = setter;
118 |     }
119 |   }
120 | 
121 |   entry.runSetters(names);
122 | };
123 | 
124 | function normalizeSetterValue(module, setter) {
125 |   if (typeof setter === "function") {
126 |     return setter;
127 |   }
128 | 
129 |   if (typeof setter === "string") {
130 |     // If the value of the setter property is a string, the setter will
131 |     // re-export the imported value using that string as the name of the
132 |     // exported value. If the string is "*", all properties of the value
133 |     // object will be re-exported as individual exports, except for the
134 |     // "default" property (use "*+" instead of "*" to include it).
135 |     return module.exportAs(setter);
136 |   }
137 | 
138 |   if (Array.isArray(setter)) {
139 |     switch (setter.length) {
140 |     case 0: return null;
141 |     case 1: return normalizeSetterValue(module, setter[0]);
142 |     default:
143 |       var setterFns = setter.map(function (elem) {
144 |         return normalizeSetterValue(module, elem);
145 |       });
146 | 
147 |       // Return a combined function that calls all of the nested setter
148 |       // functions with the same value.
149 |       return function (value) {
150 |         setterFns.forEach(function (fn) {
151 |           fn(value);
152 |         });
153 |       };
154 |     }
155 |   }
156 | 
157 |   return null;
158 | }
159 | 
160 | Ep.runGetters = function (names) {
161 |   // Before running getters, copy anything added to the exports object
162 |   // over to the namespace. Values returned by getters take precedence
163 |   // over these values, but we don't want to miss anything.
164 |   syncExportsToNamespace(this, names);
165 | 
166 |   if (names === void 0 ||
167 |       names.indexOf("*") >= 0) {
168 |     names = Object.keys(this.getters);
169 |   }
170 | 
171 |   var nameCount = names.length;
172 | 
173 |   for (var i = 0; i < nameCount; ++i) {
174 |     var name = names[i];
175 |     var value = runGetter(this, name);
176 | 
177 |     // If the getter is run without error, update both entry.namespace and
178 |     // module.exports with the current value so that CommonJS require
179 |     // calls remain consistent with module.watch.
180 |     if (value !== GETTER_ERROR) {
181 |       this.namespace[name] = value;
182 |       this.module.exports[name] = value;
183 |     }
184 |   }
185 | };
186 | 
187 | function syncExportsToNamespace(entry, names) {
188 |   var setDefault = false;
189 | 
190 |   if (entry.module === null) return;
191 |   var exports = entry.module.exports;
192 | 
193 |   if (! utils.getESModule(exports)) {
194 |     // If the module entry is managing overrides module.exports, that
195 |     // value should be exposed as the .default property of the namespace,
196 |     // unless module.exports is marked as an ECMASCript module.
197 |     entry.namespace.default = exports;
198 |     setDefault = true;
199 |   }
200 | 
201 |   if (! utils.isObjectLike(exports)) {
202 |     return;
203 |   }
204 | 
205 |   if (names === void 0 ||
206 |       names.indexOf("*") >= 0) {
207 |     names = Object.keys(exports);
208 |   }
209 | 
210 |   names.forEach(function (key) {
211 |     // Don't set any properties for which a getter function exists in
212 |     // entry.getters, don't accidentally override entry.namespace.default,
213 |     // and only copy own properties from entry.module.exports.
214 |     if (! hasOwn.call(entry.getters, key) &&
215 |         ! (setDefault && key === "default") &&
216 |         hasOwn.call(exports, key)) {
217 |       utils.copyKey(key, entry.namespace, exports);
218 |     }
219 |   });
220 | }
221 | 
222 | // Called whenever module.exports might have changed, to trigger any
223 | // setters associated with the newly exported values. The names parameter
224 | // is optional; without it, all getters and setters will run.
225 | // If the '*' setter needs to be run, but not the '*' getter (names includes
226 | // all exports/getters that changed), the runNsSetter option can be enabled.
227 | Ep.runSetters = function (names, runNsSetter) {
228 |   // Make sure entry.namespace and module.exports are up to date before we
229 |   // call getExportByName(entry, name).
230 |   this.runGetters(names);
231 | 
232 |   if (runNsSetter && names !== void 0) {
233 |     names.push('*');
234 |   }
235 | 
236 |   // Lazily-initialized object mapping parent module identifiers to parent
237 |   // module objects whose setters we might need to run.
238 |   var parents;
239 |   var parentNames;
240 | 
241 |   forEachSetter(this, names, function (setter, name, value) {
242 |     if (parents === void 0) {
243 |       parents = Object.create(null);
244 |     }
245 | 
246 |     if (parentNames === void 0) {
247 |       parentNames = Object.create(null);
248 |     }
249 | 
250 |     var parentId = setter.parent.id;
251 | 
252 |     // When setters use the shorthand for re-exporting values, we know
253 |     // which exports in the parent module were modified, and can do less work
254 |     // when running the parent setters.
255 |     // parentNames[parentId] is set to false if there are any setters that we do
256 |     // not know which exports they modify
257 |     if (setter.exportAs !== void 0 && parentNames[parentId] !== false) {
258 |       parentNames[parentId] = parentNames[parentId] || [];
259 |       parentNames[parentId].push(setter.exportAs);
260 |     } else if (parentNames[parentId] !== false) {
261 |       parentNames[parentId] = false;
262 |     }
263 | 
264 |     parents[parentId] = setter.parent;
265 | 
266 |     // The param order for setters is `value` then `name` because the `name`
267 |     // param is only used by namespace exports.
268 |     setter(value, name);
269 |   });
270 | 
271 |   if (! parents) {
272 |     return;
273 |   }
274 | 
275 |   // If any of the setters updated the module.exports of a parent module,
276 |   // or updated local variables that are exported by that parent module,
277 |   // then we must re-run any setters registered by that parent module.
278 |   var parentIDs = Object.keys(parents);
279 |   var parentIDCount = parentIDs.length;
280 | 
281 |   for (var i = 0; i < parentIDCount; ++i) {
282 |     // What happens if parents[parentIDs[id]] === module, or if
283 |     // longer cycles exist in the parent chain? Thanks to our snapshot
284 |     // bookkeeping above, the runSetters broadcast will only proceed
285 |     // as far as there are any actual changes to report.
286 |     var parent = parents[parentIDs[i]];
287 |     var parentEntry = entryMap[parent.id];
288 |     if (parentEntry) {
289 |       parentEntry.runSetters(
290 |         parentNames[parentIDs[i]] || void 0,
291 |         !!parentNames[parentIDs[i]]
292 |       );
293 |     }
294 |   }
295 | };
296 | 
297 | function createSnapshot(entry, name, newValue) {
298 |   var newSnapshot = Object.create(null);
299 |   var newKeys = [];
300 | 
301 |   if (name === "*") {
302 |     safeKeys(newValue).forEach(function (keyOfValue) {
303 |       // Evaluating value[key] is risky because the property might be
304 |       // defined by a getter function that logs a deprecation warning (or
305 |       // worse) when evaluated. For example, Node uses this trick to display
306 |       // a deprecation warning whenever crypto.createCredentials is
307 |       // accessed. Fortunately, when value[key] is defined by a getter
308 |       // function, it's enough to check whether the getter function itself
309 |       // has changed, since we are careful elsewhere to preserve getters
310 |       // rather than prematurely evaluating them.
311 |       newKeys.push(keyOfValue);
312 |       newSnapshot[keyOfValue] = normalizeSnapshotValue(
313 |         utils.valueOrGetter(newValue, keyOfValue)
314 |       );
315 |     });
316 |   } else {
317 |     newKeys.push(name);
318 |     newSnapshot[name] = normalizeSnapshotValue(newValue);
319 |   }
320 | 
321 |   var oldSnapshot = entry.snapshots[name];
322 |   if (
323 |     oldSnapshot &&
324 |     newKeys.every(function (key) {
325 |       return oldSnapshot[key] === newSnapshot[key]
326 |     }) &&
327 |     newKeys.length === Object.keys(oldSnapshot).length
328 |   ) {
329 |     return oldSnapshot;
330 |   }
331 | 
332 |   return newSnapshot;
333 | }
334 | 
335 | function normalizeSnapshotValue(value) {
336 |   if (value === void 0) return UNDEFINED;
337 |   if (value !== value && isNaN(value)) return NAN;
338 |   return value;
339 | }
340 | 
341 | // Obtain an array of keys in entry.setters[name] for which we need to run a
342 | // setter function. If successful, entry.snapshot[name] will be updated and/or
343 | // entry.newSetters[name] will be removed, so the returned keys will not be
344 | // returned again until after the snapshot changes again. If the snapshot hasn't
345 | // changed and there aren't any entry.newSetters[name] keys, this function
346 | // returns undefined, to avoid allocating an empty array in the common case.
347 | function consumeKeysGivenSnapshot(entry, name, snapshot) {
348 |   if (entry.snapshots[name] !== snapshot) {
349 |     entry.snapshots[name] = snapshot;
350 |     // Since the keys of entry.newSetters[name] are a subset of those of
351 |     // entry.setters[name], we can consume entry.newSetters[name] here too.
352 |     delete entry.newSetters[name];
353 |     return Object.keys(entry.setters[name]);
354 |   }
355 | 
356 |   // If new setters have been added to entry.setters (and thus also to
357 |   // entry.newSetters) since we last recorded entry.snapshots[name], we need to
358 |   // run those setters (for the first time) in order to consider them up-to-date
359 |   // with respect to entry.snapshots[name].
360 |   var news = entry.newSetters[name];
361 |   var newKeys = news && Object.keys(news);
362 |   if (newKeys && newKeys.length) {
363 |     // Consume the new keys so we don't consider them again.
364 |     delete entry.newSetters[name];
365 |     return newKeys;
366 |   }
367 | }
368 | 
369 | // Invoke the given callback once for every (setter, name, value) that needs to
370 | // be called. Note that forEachSetter does not call any setters itself, only the
371 | // given callback.
372 | function forEachSetter(entry, names, callback) {
373 |   if (names === void 0) {
374 |     names = Object.keys(entry.setters);
375 |   }
376 | 
377 |   names.forEach(function (name) {
378 |     // Ignore setters asking for module.exports.__esModule.
379 |     if (name === "__esModule") return;
380 | 
381 |     var settersByKey = entry.setters[name];
382 |     if (!settersByKey) return;
383 | 
384 |     var getter = entry.getters[name];
385 |     var alreadyCalledConstantGetter =
386 |       typeof getter === "function" &&
387 |       // Sometimes a getter function will throw because it's called
388 |       // before the variable it's supposed to return has been
389 |       // initialized, so we need to know that the getter function has
390 |       // run to completion at least once.
391 |       getter.runCount > 0 &&
392 |       getter.constant;
393 | 
394 |     var value = getExportByName(entry, name);
395 | 
396 |     // Although we may have multiple setter functions with different keys in
397 |     // settersByKey, we can compute a snapshot of value and check it against
398 |     // entry.snapshots[name] before iterating over the individual setter
399 |     // functions
400 |     var snapshot = createSnapshot(entry, name, value);
401 | 
402 |     var keys = consumeKeysGivenSnapshot(entry, name, snapshot);
403 |     if (keys === void 0) return;
404 | 
405 |     keys.forEach(function (key) {
406 |       var setter = settersByKey[key];
407 |       if (!setter) {
408 |         return;
409 |       }
410 | 
411 |       // Invoke the setter function with the updated value.
412 |       callback(setter, name, value);
413 | 
414 |       if (alreadyCalledConstantGetter) {
415 |         // If we happen to know this getter function has run successfully
416 |         // (getter.runCount > 0), and will never return a different value
417 |         // (getter.constant), then we can forget the corresponding setter,
418 |         // because we've already reported that constant value. Note that we
419 |         // can't forget the getter, because we need to remember the original
420 |         // value in case anyone tampers with entry.module.exports[name].
421 |         delete settersByKey[key];
422 |       }
423 |     });
424 |   });
425 | }
426 | 
427 | function getExportByName(entry, name) {
428 |   if (name === "*") {
429 |     return entry.namespace;
430 |   }
431 | 
432 |   if (hasOwn.call(entry.namespace, name)) {
433 |     return entry.namespace[name];
434 |   }
435 | 
436 |   if (entry.module === null) return;
437 |   var exports = entry.module.exports;
438 | 
439 |   if (name === "default" &&
440 |       ! (utils.getESModule(exports) &&
441 |          "default" in exports)) {
442 |     return exports;
443 |   }
444 | 
445 |   if (exports == null) {
446 |     return;
447 |   }
448 | 
449 |   return exports[name];
450 | }
451 | 
452 | function makeUniqueKey() {
453 |   return Math.random()
454 |     .toString(36)
455 |     // Add an incrementing salt to help track key ordering and also
456 |     // absolutely guarantee we never return the same key twice.
457 |     .replace("0.", ++keySalt + "$");
458 | }
459 | 
460 | function runGetter(entry, name) {
461 |   var getter = entry.getters[name];
462 |   if (!getter) return GETTER_ERROR;
463 |   try {
464 |     var result = getter();
465 |     ++getter.runCount;
466 |     return result;
467 |   } catch (e) {}
468 |   return GETTER_ERROR;
469 | }
470 | 
471 | module.exports = Entry;
472 | 


--------------------------------------------------------------------------------
/lib/runtime/index.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | // This module should be compatible with PhantomJS v1, just like the other files
  4 | // in reify/lib/runtime. Node 4+ features like const/let and arrow functions are
  5 | // not acceptable here, and importing any npm packages should be contemplated
  6 | // with extreme skepticism.
  7 | 
  8 | var utils = require("./utils.js");
  9 | var Entry = require("./entry.js");
 10 | 
 11 | // The exports.enable method can be used to enable the Reify runtime for
 12 | // specific module objects, or for Module.prototype (where implemented),
 13 | // to make the runtime available throughout the entire module system.
 14 | exports.enable = function (mod) {
 15 |   if (mod.link !== moduleLink) {
 16 |     mod.link = moduleLink;
 17 |     mod["export"] = moduleExport;
 18 |     mod.exportDefault = moduleExportDefault;
 19 |     mod.exportAs = moduleExportAs;
 20 |     mod.runSetters = runSetters;
 21 | 
 22 |     // Legacy shorthand for mod.exportAs("*").
 23 |     mod.makeNsSetter = moduleMakeNsSetter;
 24 | 
 25 |     return true;
 26 |   }
 27 | 
 28 |   return false;
 29 | };
 30 | 
 31 | // Calling module.link(id, setters) resolves the given ID using
 32 | // module.resolve(id), which should return a canonical absolute module
 33 | // identifier string (like require.resolve); then creates an Entry object
 34 | // for the child module and evaluates its code (if this is the first time
 35 | // it has been imported) by calling module.require(id). Finally, the
 36 | // provided setter functions will be called with values exported by the
 37 | // module, possibly multiple times when/if those exported values change.
 38 | // The module.link name is intended to evoke the "liveness" of the
 39 | // exported bindings, since we are subscribing to all future exports of
 40 | // the child module, not just taking a snapshot of its current exports.
 41 | function moduleLink(id, setters, key) {
 42 |   utils.setESModule(this.exports);
 43 |   Entry.getOrCreate(this.id, this);
 44 | 
 45 |   var absChildId = this.resolve(id);
 46 |   var childEntry = Entry.getOrCreate(absChildId);
 47 | 
 48 |   if (utils.isObject(setters)) {
 49 |     childEntry.addSetters(this, setters, key);
 50 |   }
 51 | 
 52 |   var exports = this.require(absChildId);
 53 | 
 54 |   if (childEntry.module === null) {
 55 |     childEntry.module = {
 56 |       id: absChildId,
 57 |       exports: exports
 58 |     };
 59 |   }
 60 | 
 61 |   childEntry.runSetters();
 62 | }
 63 | 
 64 | // Register getter functions for local variables in the scope of an export
 65 | // statement. Pass true as the second argument to indicate that the getter
 66 | // functions always return the same values.
 67 | function moduleExport(getters, constant) {
 68 |   utils.setESModule(this.exports);
 69 |   var entry = Entry.getOrCreate(this.id, this);
 70 |   entry.addGetters(getters, constant);
 71 |   if (this.loaded) {
 72 |     // If the module has already been evaluated, then we need to trigger
 73 |     // another round of entry.runSetters calls, which begins by calling
 74 |     // entry.runModuleGetters(module).
 75 |     entry.runSetters();
 76 |   }
 77 | }
 78 | 
 79 | // Register a getter function that always returns the given value.
 80 | function moduleExportDefault(value) {
 81 |   return this["export"]({
 82 |     "default": function () {
 83 |       return value;
 84 |     }
 85 |   }, true);
 86 | }
 87 | 
 88 | // Returns a function suitable for passing as a setter callback to
 89 | // module.link. If name is an identifier, calling the function will set
 90 | // the export of that name to the given value. If the name is "*", all
 91 | // properties of the value object will be exported by name, except for
 92 | // "default" (use "*+" instead of "*" to include it). Why the "default"
 93 | // property is skipped: https://github.com/tc39/ecma262/issues/948
 94 | function moduleExportAs(name) {
 95 |   var entry = this;
 96 |   var includeDefault = name === "*+";
 97 |   var setter = function (value) {
 98 |     if (name === "*" || name === "*+") {
 99 |       Object.keys(value).forEach(function (key) {
100 |         if (includeDefault || key !== "default") {
101 |           utils.copyKey(key, entry.exports, value);
102 |         }
103 |       });
104 |     } else {
105 |       entry.exports[name] = value;
106 |     }
107 |   };
108 | 
109 |   if (name !== '*+' && name !== "*") {
110 |     setter.exportAs = name;
111 |   }
112 | 
113 |   return setter;
114 | }
115 | 
116 | // Platform-specific code should find a way to call this method whenever
117 | // the module system is about to return module.exports from require. This
118 | // might happen more than once per module, in case of dependency cycles,
119 | // so we want Module.prototype.runSetters to run each time.
120 | function runSetters(valueToPassThrough) {
121 |   Entry.getOrCreate(this.id, this).runSetters();
122 | 
123 |   // Assignments to exported local variables get wrapped with calls to
124 |   // module.runSetters, so module.runSetters returns the
125 |   // valueToPassThrough parameter to allow the value of the original
126 |   // expression to pass through. For example,
127 |   //
128 |   //   export var a = 1;
129 |   //   console.log(a += 3);
130 |   //
131 |   // becomes
132 |   //
133 |   //   module.export("a", () => a);
134 |   //   var a = 1;
135 |   //   console.log(module.runSetters(a += 3));
136 |   //
137 |   // This ensures module.runSetters runs immediately after the assignment,
138 |   // and does not interfere with the larger computation.
139 |   return valueToPassThrough;
140 | }
141 | 
142 | // Legacy helper that returns a function that takes a namespace object and
143 | // copies the properties of the namespace to module.exports, excluding any
144 | // "default" property (unless includeDefault is true), which is useful for
145 | // implementing `export * from "module"`.
146 | //
147 | // Instead of using this helper like so:
148 | //
149 | //   module.link(id, { "*": module.makeNsSetter() });
150 | //
151 | // non-legacy code should simply use a string-valued setter:
152 | //
153 | //   module.link(id, { "*": "*" });
154 | //
155 | // or, to include the "default" property:
156 | //
157 | //   module.link(id, { "*": "*+" });
158 | //
159 | // This helper may be removed in a future version of Reify.
160 | function moduleMakeNsSetter(includeDefault) {
161 |   return this.exportAs(includeDefault ? "*+" : "*");
162 | }
163 | 


--------------------------------------------------------------------------------
/lib/runtime/utils.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | // This module should be compatible with PhantomJS v1, just like the other files
  4 | // in reify/lib/runtime. Node 4+ features like const/let and arrow functions are
  5 | // not acceptable here, and importing any npm packages should be contemplated
  6 | // with extreme skepticism.
  7 | 
  8 | var useSetPrototypeOf = typeof Object.setPrototypeOf === "function";
  9 | var useSymbol = typeof Symbol === "function";
 10 | 
 11 | var esStrKey = "__esModule";
 12 | var esSymKey = useSymbol ? Symbol.for(esStrKey) : null;
 13 | var useToStringTag = useSymbol && typeof Symbol.toStringTag === "symbol";
 14 | var useGetOwnPropDesc =
 15 |   typeof Object.getOwnPropertyDescriptor === "function";
 16 | var hasOwn = Object.prototype.hasOwnProperty;
 17 | 
 18 | function copyKey(key, target, source) {
 19 |   if (useGetOwnPropDesc) {
 20 |     var desc = Object.getOwnPropertyDescriptor(source, key);
 21 |     desc.configurable = true; // Allow redefinition.
 22 |     Object.defineProperty(target, key, desc);
 23 |   } else {
 24 |     target[key] = source[key];
 25 |   }
 26 | }
 27 | 
 28 | exports.copyKey = copyKey;
 29 | 
 30 | // Returns obj[key] unless that property is defined by a getter function,
 31 | // in which case the getter function is returned.
 32 | exports.valueOrGetter = function (obj, key) {
 33 |   if (useGetOwnPropDesc && hasOwn.call(obj, key)) {
 34 |     var desc = Object.getOwnPropertyDescriptor(obj, key);
 35 |     if (typeof desc.get === "function") {
 36 |       return desc.get;
 37 |     }
 38 |   }
 39 | 
 40 |   return obj[key];
 41 | };
 42 | 
 43 | function getESModule(exported) {
 44 |   if (isObjectLike(exported)) {
 45 |     if (useSymbol && hasOwn.call(exported, esSymKey)) {
 46 |       return !! exported[esSymKey];
 47 |     }
 48 | 
 49 |     if (hasOwn.call(exported, esStrKey)) {
 50 |       return !! exported[esStrKey];
 51 |     }
 52 |   }
 53 | 
 54 |   return false;
 55 | }
 56 | 
 57 | exports.getESModule = getESModule;
 58 | 
 59 | function setESModule(exported) {
 60 |   if (isObjectLike(exported)) {
 61 |     if (useSymbol) {
 62 |       exported[esSymKey] = true;
 63 |     }
 64 | 
 65 |     if (! exported[esStrKey]) {
 66 |       // Other module runtime systems may set exported.__esModule such
 67 |       // that it can't be redefined, so we call Object.defineProperty only
 68 |       // when exported.__esModule is not already true.
 69 |       Object.defineProperty(exported, esStrKey, {
 70 |         configurable: true,
 71 |         enumerable: false,
 72 |         value: true,
 73 |         writable: false
 74 |       });
 75 |     }
 76 |   }
 77 | }
 78 | 
 79 | exports.setESModule = setESModule;
 80 | 
 81 | function isObject(value) {
 82 |   return typeof value === "object" && value !== null;
 83 | }
 84 | 
 85 | exports.isObject = isObject;
 86 | 
 87 | function isObjectLike(value) {
 88 |   var type = typeof value;
 89 |   return type === "function" || (type === "object" && value !== null);
 90 | }
 91 | 
 92 | exports.isObjectLike = isObjectLike;
 93 | 
 94 | exports.ensureObjectProperty = function (object, propertyName) {
 95 |   return hasOwn.call(object, propertyName)
 96 |     ? object[propertyName]
 97 |     : object[propertyName] = Object.create(null);
 98 | };
 99 | 
100 | function createNamespace() {
101 |   var namespace = Object.create(null);
102 | 
103 |   if (useToStringTag) {
104 |     Object.defineProperty(namespace, Symbol.toStringTag, {
105 |       value: "Module",
106 |       configurable: false,
107 |       enumerable: false,
108 |       writable: false
109 |     });
110 |   }
111 | 
112 |   setESModule(namespace);
113 | 
114 |   return namespace;
115 | }
116 | 
117 | exports.createNamespace = createNamespace;
118 | 
119 | function setPrototypeOf(object, proto) {
120 |   if (useSetPrototypeOf) {
121 |     Object.setPrototypeOf(object, proto);
122 |   } else {
123 |     object.__proto__ = proto;
124 |   }
125 |   return object;
126 | }
127 | 
128 | exports.setPrototypeOf = setPrototypeOf;
129 | 


--------------------------------------------------------------------------------
/lib/transform.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const AV = require("./assignment-visitor.js");
 4 | const FastPath = require("./fast-path.js");
 5 | const IEV = require("./import-export-visitor.js");
 6 | 
 7 | const assignmentVisitor = new AV;
 8 | const importExportVisitor = new IEV;
 9 | 
10 | module.exports = function (ast, options) {
11 |   const importExportOptions = Object.assign(Object.create(null), options);
12 |   const rootPath = new FastPath(ast);
13 | 
14 |   // Essential so that the AST will be modified.
15 |   importExportOptions.ast = true;
16 | 
17 |   importExportVisitor.visit(
18 |     rootPath,
19 |     null, // No code to modify.
20 |     importExportOptions
21 |   );
22 | 
23 |   const result = { ast, identical: false };
24 | 
25 |   if (importExportVisitor.madeChanges) {
26 |     assignmentVisitor.visit(rootPath, {
27 |       exportedLocalNames: importExportVisitor.exportedLocalNames,
28 |       moduleAlias: importExportOptions.moduleAlias,
29 |       modifyAST: true
30 |     });
31 |   } else {
32 |     // Let the caller know the result is no different from the input.
33 |     result.identical = true;
34 |   }
35 | 
36 |   // Whether or not there were any changes, finalizeHoisting does some
37 |   // important cleanup work, and should not be computationally expensive
38 |   // when no changes need to be made.
39 |   importExportVisitor.finalizeHoisting();
40 | 
41 |   return result;
42 | };
43 | 


--------------------------------------------------------------------------------
/lib/utils.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | // Using Node 4+ features is safe in this module, because it is not depended
  4 | // upon by reify/lib/runtime.
  5 | 
  6 | const acorn = require("acorn");
  7 | const dummyParser = new acorn.Parser;
  8 | const utils = Object.assign(exports, require("./runtime/utils.js"));
  9 | 
 10 | const codeOfA = "A".charCodeAt(0);
 11 | const codeOfZ = "Z".charCodeAt(0);
 12 | 
 13 | function getNamesFromPattern(pattern) {
 14 |   const names = [];
 15 |   const queue = [pattern];
 16 | 
 17 |   for (var i = 0; i < queue.length; ++i) {
 18 |     const pattern = queue[i];
 19 |     if (pattern === null) {
 20 |       // The ArrayPattern .elements array can contain null to indicate that
 21 |       // the position is a hole.
 22 |       continue;
 23 |     }
 24 | 
 25 |     // Cases are ordered from most to least likely to encounter.
 26 |     switch (pattern.type) {
 27 |     case "Identifier":
 28 |       names.push(pattern.name);
 29 |       break;
 30 |     case "Property":
 31 |     case "ObjectProperty":
 32 |       queue.push(pattern.value);
 33 |       break;
 34 |     case "AssignmentPattern":
 35 |       queue.push(pattern.left);
 36 |       break;
 37 |     case "ObjectPattern":
 38 |       queue.push.apply(queue, pattern.properties);
 39 |       break;
 40 |     case "ArrayPattern":
 41 |       queue.push.apply(queue, pattern.elements);
 42 |       break;
 43 |     case "RestElement":
 44 |       queue.push(pattern.argument);
 45 |       break;
 46 |     }
 47 |   }
 48 | 
 49 |   return names;
 50 | }
 51 | 
 52 | exports.getNamesFromPattern = getNamesFromPattern;
 53 | 
 54 | function isCapitalized(string) {
 55 |   if (typeof string !== "string") {
 56 |     return false;
 57 |   }
 58 |   const code = string.charCodeAt(0);
 59 |   return code >= codeOfA && code <= codeOfZ;
 60 | }
 61 | 
 62 | exports.isCapitalized = isCapitalized;
 63 | 
 64 | function isNodeLike(value) {
 65 |   // Without a complete list of Node .type names, we have to settle for this
 66 |   // fuzzy matching of object shapes. However, the infeasibility of
 67 |   // maintaining a complete list of type names is one of the reasons we're
 68 |   // using the FastPath/Visitor abstraction in the first place.
 69 |   return utils.isObject(value) &&
 70 |     ! Array.isArray(value) &&
 71 |     isCapitalized(value.type);
 72 | }
 73 | 
 74 | exports.isNodeLike = isNodeLike;
 75 | 
 76 | function lookahead(parser) {
 77 |   dummyParser.input = parser.input;
 78 |   dummyParser.pos = parser.pos;
 79 |   dummyParser.nextToken();
 80 |   return dummyParser;
 81 | }
 82 | 
 83 | exports.lookahead = lookahead;
 84 | 
 85 | function toString(value) {
 86 |   if (typeof value === "string") {
 87 |     return value;
 88 |   }
 89 |   return value == null ? "" : String(value);
 90 | }
 91 | 
 92 | exports.toString = toString;
 93 | 
 94 | // Returns a sorted array of possible indexes within the code string where
 95 | // any identifier in the identifiers array might appear. This information
 96 | // can be used to optimize AST traversal by allowing subtrees to be
 97 | // ignored if they don't contain any possible indexes.
 98 | function findPossibleIndexes(code, identifiers, filter) {
 99 |   const possibleIndexes = [];
100 | 
101 |   if (identifiers.length === 0) {
102 |     return possibleIndexes;
103 |   }
104 | 
105 |   const pattern = new RegExp(
106 |     "\\b(?:" + identifiers.join("|") + ")\\b",
107 |     "g"
108 |   );
109 | 
110 |   let match;
111 |   pattern.lastIndex = 0;
112 |   while ((match = pattern.exec(code))) {
113 |     if (typeof filter !== "function" || filter(match)) {
114 |       possibleIndexes.push(match.index);
115 |     }
116 |   }
117 | 
118 |   return possibleIndexes;
119 | }
120 | 
121 | exports.findPossibleIndexes = findPossibleIndexes;
122 | 
123 | function findLikelyIndexes(code, identifiers) {
124 |   return findPossibleIndexes(code, identifiers, function (match) {
125 |     // Make sure the match is not preceded by a `.` character, since that
126 |     // probably means the identifier is a property access rather than a
127 |     // variable reference.
128 |     return match.index < 1 ||
129 |       code.charAt(match.index - 1) !== ".";
130 |   });
131 | }
132 | 
133 | exports.findLikelyIndexes = findLikelyIndexes;
134 | 


--------------------------------------------------------------------------------
/lib/visitor.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const utils = require("./utils.js");
  4 | const FastPath = require("./fast-path.js");
  5 | const codeOfUnderscore = "_".charCodeAt(0);
  6 | 
  7 | // This Visitor API was inspired by a similar API provided by ast-types:
  8 | // https://github.com/benjamn/ast-types/blob/master/lib/path-visitor.js
  9 | 
 10 | class Visitor {
 11 |   constructor() {
 12 |     const that = this;
 13 |     const visit = this.visit;
 14 |     const visitWithoutReset = this.visitWithoutReset;
 15 |     const visitChildren = this.visitChildren;
 16 | 
 17 |     // Avoid slower `Function#bind` for Node < 7.
 18 |     this.visit = function () {
 19 |       visit.apply(that, arguments);
 20 |     };
 21 | 
 22 |     this.visitWithoutReset = function (path) {
 23 |       visitWithoutReset.call(that, path);
 24 |     };
 25 | 
 26 |     this.visitChildren = function (path) {
 27 |       visitChildren.call(that, path);
 28 |     };
 29 | 
 30 |     // Define some internal properties before the constructor returns to
 31 |     // help the JS engine understand the shape of the visitor object.
 32 |     this._beforeReset();
 33 |   }
 34 | 
 35 |   _beforeReset() {
 36 |     // Since this.possibleIndexes can cause the traversal to ignore entire
 37 |     // subtrees if misused, it's important to force the reset method to
 38 |     // redefine it each time the visit method is called.
 39 |     this.possibleIndexes = null;
 40 |     this._piLowerBound = 0;
 41 |     this._piUpperBound = 0;
 42 |   }
 43 | 
 44 |   // The reset method does nothing unless it is overridden.
 45 |   reset() {}
 46 | 
 47 |   _afterReset() {
 48 |     // Reset the bounds we are currently considering within
 49 |     // this.possibleIndexes, so that we can adjust the bounds in
 50 |     // _visitChildrenIfPossible below. This allows us to pretend we're
 51 |     // working with this.possibleIndexes.slice(this._piLowerBound,
 52 |     // this._piUpperBound) without actually modifying the array.
 53 |     if (Array.isArray(this.possibleIndexes)) {
 54 |       this._piUpperBound = this.possibleIndexes.length;
 55 |     }
 56 |   }
 57 | 
 58 |   visit(astOrPath) {
 59 |     const args = Array.prototype.slice.call(arguments);
 60 |     const path = args[0] = FastPath.from(astOrPath);
 61 |     this._beforeReset();
 62 |     // The user-defined reset method has a chance to (re)initialize any
 63 |     // instance variables, including this.possibleIndexes.
 64 |     this.reset.apply(this, args);
 65 |     this._afterReset();
 66 |     this.visitWithoutReset(path);
 67 |   }
 68 | 
 69 |   visitWithoutReset(path) {
 70 |     const value = path.getValue();
 71 |     if (Array.isArray(value)) {
 72 |       path.each(this.visitWithoutReset);
 73 |     } else if (path.getNode() === value) {
 74 |       const method = this["visit" + value.type];
 75 |       if (typeof method === "function") {
 76 |         // The method must call this.visitChildren(path) to continue traversing.
 77 |         method.call(this, path);
 78 |       } else {
 79 |         // Only continue the search if this.possibleIndexes is undefined,
 80 |         // or if [node.start, node.end) contains at least one possible
 81 |         // index of an identifier that we care about.
 82 |         this._visitChildrenIfPossible(path);
 83 |       }
 84 |     }
 85 |   }
 86 | 
 87 |   // Calls this.visitChildren(nodePath) unless this.possibleIndexes is
 88 |   // defined and we can determine that the current [node.start, node.end)
 89 |   // interval does not contain any of the possible indexes we care about.
 90 |   _visitChildrenIfPossible(nodePath) {
 91 |     const array = this.possibleIndexes;
 92 |     if (! array) {
 93 |       // If this.possibleIndexes is not defined, then we don't know
 94 |       // anything about where (not) to look, so err on the side of
 95 |       // visiting the children.
 96 |       return this.visitChildren(nodePath);
 97 |     }
 98 | 
 99 |     const node = nodePath.getValue();
100 | 
101 |     if (node.type === "File" ||
102 |         node.type === "Program") {
103 |       // Always visit children of File and Program AST nodes, since
104 |       // they're always near the root of the AST, and they don't have any
105 |       // identifiers of their own that aren't part of other nodes, so it
106 |       // might be awkward to use this.possibleIndexes to include them.
107 |       return this.visitChildren(nodePath);
108 |     }
109 | 
110 |     const start = node.start;
111 |     const end = node.end;
112 | 
113 |     if (typeof start !== "number" ||
114 |         typeof end !== "number") {
115 |       // If we don't have start/end for this node, err on the side of
116 |       // visiting the children.
117 |       return this.visitChildren(nodePath);
118 |     }
119 | 
120 |     // Save the current this._pi{Lower,Upper}Bound values so that we can
121 |     // restore them at the end of this method.
122 |     const oldLowerBound = this._piLowerBound;
123 |     const oldUpperBound = this._piUpperBound;
124 | 
125 |     let lowerBound = typeof oldLowerBound === "number" ? oldLowerBound : 0;
126 |     let upperBound = typeof oldUpperBound === "number" ? oldUpperBound : array.length;
127 | 
128 |     // Find the first possible index not less than node.start. While a
129 |     // binary search might seem more efficient here, remember that we are
130 |     // descending a tree of nested AST nodes, with each new [node.start,
131 |     // node.end) interval getting a little smaller at every level. This
132 |     // while loop is responsible for closing the gap since the last time
133 |     // we updated the lower bound, which means lowerBound should only need
134 |     // to be incremented a small number of times, whereas a binary search
135 |     // would take log_2(array.length - lowerBound) steps.
136 |     while (lowerBound < upperBound &&
137 |            array[lowerBound] < start) {
138 |       ++lowerBound;
139 |     }
140 | 
141 |     // Find the first possible index greater than node.end. Again, a
142 |     // binary search would be more expensive here, since we expect to
143 |     // decrement upperBound only a small number of times, typically.
144 |     while (lowerBound < upperBound &&
145 |            end < array[upperBound - 1]) {
146 |       --upperBound;
147 |     }
148 | 
149 |     // Now array.slice(lowerBound, upperBound) contains exactly the
150 |     // subsequence of possible indexes that are contained by the interval
151 |     // [node.start, node.end). If that interval is empty, then this node
152 |     // does not contain any of the indexes we care about, and we can avoid
153 |     // visiting its children. If the interval is non-empty, first update
154 |     // this._pi{Lower,Upper}Bound, then visit the children, then reset
155 |     // this._pi{Lower,Upper}Bound to the old{Upper,Lower}Bound values.
156 |     if (lowerBound < upperBound) {
157 |       this._piLowerBound = lowerBound;
158 |       this._piUpperBound = upperBound;
159 |       this.visitChildren(nodePath);
160 |       this._piLowerBound = oldLowerBound;
161 |       this._piUpperBound = oldUpperBound;
162 |     }
163 |   }
164 | 
165 |   visitChildren(path) {
166 |     if (! path.valueIsNode()) {
167 |       return;
168 |     }
169 | 
170 |     const node = path.getValue();
171 |     const keys = Object.keys(node);
172 |     const keyCount = keys.length;
173 | 
174 |     for (let i = 0; i < keyCount; ++i) {
175 |       const key = keys[i];
176 | 
177 |       // Ignore .loc.{start,end} objects.
178 |       if (key === "loc") {
179 |         continue;
180 |       }
181 | 
182 |       // Ignore "private" properties added by Babel.
183 |       if (key.charCodeAt(0) === codeOfUnderscore) {
184 |         continue;
185 |       }
186 | 
187 |       const value = node[key];
188 | 
189 |       // Ignore properties whose values aren't objects.
190 |       if (! utils.isObject(value)) {
191 |         continue;
192 |       }
193 | 
194 |       path.call(this.visitWithoutReset, key);
195 |     }
196 |   }
197 | };
198 | 
199 | Object.setPrototypeOf(Visitor.prototype, null);
200 | 
201 | module.exports = Visitor;
202 | 


--------------------------------------------------------------------------------
/node/caching-compiler.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const compile = require("../lib/compiler.js").compile;
 4 | const dynRequire = module.require ? module.require.bind(module) : __non_webpack_require__;
 5 | const fs = require("./fs.js");
 6 | const path = require("path");
 7 | const utils = require("./utils.js");
 8 | 
 9 | exports.compile = (content, options) => {
10 |   options = Object.assign({}, options);
11 |   return typeof options.filePath === "string"
12 |     ? compileWithFilename(content, options)
13 |     : compileAndCache(content, options);
14 | };
15 | 
16 | function compileWithFilename(content, options) {
17 |   try {
18 |     return compileAndWrite(content, options);
19 |   } catch (e) {
20 |     e.message += " while processing file: " + options.filePath;
21 |     throw e;
22 |   }
23 | }
24 | 
25 | function compileAndCache(content, options) {
26 |   const result = compile(content, toCompileOptions(options));
27 |   return options.pkgInfo.cache[options.cacheFilename] = result.code;
28 | }
29 | 
30 | function compileAndWrite(content, options) {
31 |   const result = compile(content, toCompileOptions(options));
32 |   const code = result.code;
33 | 
34 |   if (! result.identical) {
35 |     // Only cache if the compiler made changes.
36 |     const cacheFilePath = path.join(options.cachePath, options.cacheFilename);
37 |     const encoding = "utf8";
38 |     const scopePath = options.pkgInfo.path;
39 | 
40 |     fs.writeFileDefer(cacheFilePath, code, { encoding, scopePath });
41 |   }
42 | 
43 |   return code;
44 | }
45 | 
46 | function toCompileOptions(options) {
47 |   const compileOptions = {
48 |     parse: void 0,
49 |     sourceType: void 0
50 |   };
51 | 
52 |   const filePath = options.filePath;
53 |   const config = options.pkgInfo.config;
54 | 
55 |   if (typeof config.parser === "string") {
56 |     compileOptions.parse = dynRequire(config.parser).parse;
57 |   }
58 | 
59 |   if (typeof filePath === "string") {
60 |     let ext = path.extname(filePath);
61 | 
62 |     if (ext === ".gz") {
63 |       ext = path.extname(path.basename(filePath, ext));
64 |     }
65 | 
66 |     if (typeof config.sourceType === "string") {
67 |       compileOptions.sourceType = config.sourceType;
68 |     } else if (ext === ".mjs") {
69 |       compileOptions.sourceType = "module";
70 |     }
71 |   }
72 | 
73 |   return compileOptions;
74 | }
75 | 


--------------------------------------------------------------------------------
/node/compile-hook.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const compiler = require("./caching-compiler.js");
 4 | const exts = require("module")._extensions;
 5 | const fs = require("./fs.js");
 6 | const path = require("path");
 7 | const runtime = require("../lib/runtime");
 8 | const utils = require("./utils.js");
 9 | const wrapper = require("./wrapper.js");
10 | 
11 | function extManager(func, mod, filename) {
12 |   const filePath = path.resolve(filename);
13 |   const pkgInfo = utils.getPkgInfo(path.dirname(filePath));
14 |   const wrap = pkgInfo === null ? null : wrapper.find(exts, ".js", pkgInfo.range);
15 | 
16 |   // A wrapper should only be null for reify < 0.10.
17 |   return wrap === null
18 |     ? func.call(this, mod, filePath)
19 |     : wrap.call(this, func, pkgInfo, mod, filePath);
20 | }
21 | 
22 | function extWrap(func, pkgInfo, mod, filePath) {
23 |   const cachePath = pkgInfo.cachePath;
24 |   if (cachePath === null) {
25 |     return func.call(this, mod, filePath);
26 |   }
27 | 
28 |   const cache = pkgInfo.cache;
29 |   const cacheKey = fs.mtime(filePath);
30 |   const cacheFilename = utils.getCacheFileName(filePath, cacheKey, pkgInfo);
31 | 
32 |   let cacheValue = cache[cacheFilename];
33 | 
34 |   if (cacheValue === true) {
35 |     const cacheFilePath = path.join(cachePath, cacheFilename);
36 |     cacheValue = fs.readFile(cacheFilePath, "utf8");
37 | 
38 |   } else if (typeof cacheValue !== "string") {
39 |     const options = {
40 |       cacheFilename,
41 |       cachePath,
42 |       filePath,
43 |       pkgInfo
44 |     };
45 | 
46 |     const content = fs.readFile(filePath, "utf8");
47 |     cacheValue = compiler.compile(content, options);
48 |   }
49 | 
50 |   cache[cacheFilename] = cacheValue;
51 | 
52 |   runtime.enable(mod);
53 |   mod._compile(cacheValue, filePath);
54 | 
55 |   if (! mod.loaded) {
56 |     mod.loaded = true;
57 |     mod.runSetters();
58 |   }
59 | }
60 | 
61 | wrapper.manage(exts, ".js", extManager);
62 | wrapper.add(exts, ".js", extWrap);
63 | 
64 | const extsJs = wrapper.getMap(exts, ".js").raw;
65 | 
66 | [".gz", ".js.gz", ".mjs.gz", ".mjs"].forEach((key) => {
67 |   if (typeof exts[key] !== "function") {
68 |     // Mimic the built-in Node behavior of treating files with unrecognized
69 |     // extensions as .js.
70 |     exts[key] = extsJs;
71 |   }
72 |   wrapper.manage(exts, key, extManager);
73 |   wrapper.add(exts, key, extWrap);
74 | });
75 | 


--------------------------------------------------------------------------------
/node/data.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const FastObject = require("../lib/fast-object.js");
 4 | 
 5 | // Map absolute file paths to the package info that governs them.
 6 | const pkgInfo = new FastObject;
 7 | 
 8 | // Enable in-memory caching when compiling without a file path.
 9 | pkgInfo[""] = {
10 |   cache: Object.create(null),
11 |   cachePath: null,
12 |   config: Object.create(null),
13 |   range: require("./version.js").version
14 | };
15 | 
16 | exports.pkgInfo = pkgInfo;
17 | 


--------------------------------------------------------------------------------
/node/fs.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const fs = require("fs");
  4 | const path = require("path");
  5 | const utils = require("../lib/utils.js");
  6 | const zlib = require("zlib");
  7 | 
  8 | const FastObject = require("../lib/fast-object.js");
  9 | 
 10 | let pendingWriteTimer = null;
 11 | const pendingWrites = new FastObject;
 12 | 
 13 | function fallbackIsDirectory(filePath) {
 14 |   try {
 15 |     return fs.statSync(filePath).isDirectory();
 16 |   } catch (e) {}
 17 |   return false;
 18 | }
 19 | 
 20 | function fallbackMtime(filePath) {
 21 |   try {
 22 |     return fs.statSync(filePath).mtime.getTime();
 23 |   } catch (e) {}
 24 |   return -1;
 25 | }
 26 | 
 27 | function fallbackReadFile(filePath, options) {
 28 |   try {
 29 |     return fs.readFileSync(filePath, options);
 30 |   } catch (e) {}
 31 |   return null;
 32 | }
 33 | 
 34 | function streamToBuffer(stream, bufferOrString) {
 35 |   const result = [];
 36 |   stream.on("data", chunk => result.push(chunk)).end(bufferOrString);
 37 |   return Buffer.concat(result);
 38 | }
 39 | 
 40 | function isDirectory(thepath) {
 41 |   return fallbackIsDirectory(thepath);
 42 | }
 43 | 
 44 | exports.isDirectory = isDirectory;
 45 | 
 46 | function mkdir(dirPath) {
 47 |   try {
 48 |     fs.mkdirSync(dirPath);
 49 |     return true;
 50 |   } catch (e) {}
 51 |   return false;
 52 | }
 53 | 
 54 | exports.mkdir = mkdir;
 55 | 
 56 | function mkdirp(dirPath, scopePath) {
 57 |   const parentPath = path.dirname(dirPath);
 58 |   if (dirPath === parentPath || dirPath === scopePath) {
 59 |     return true;
 60 |   }
 61 |   if (mkdirp(parentPath, scopePath)) {
 62 |     return isDirectory(dirPath) || mkdir(dirPath);
 63 |   }
 64 |   return false;
 65 | }
 66 | 
 67 | exports.mkdirp = mkdirp;
 68 | 
 69 | function mtime(filePath) {
 70 |   return fallbackMtime(filePath);
 71 | }
 72 | 
 73 | exports.mtime = mtime;
 74 | 
 75 | function readdir(dirPath) {
 76 |   try {
 77 |     return fs.readdirSync(dirPath);
 78 |   } catch (e) {}
 79 |   return null;
 80 | }
 81 | 
 82 | exports.readdir = readdir;
 83 | 
 84 | function readFile(filePath, options) {
 85 |   return fallbackReadFile(filePath, options);
 86 | }
 87 | 
 88 | exports.readFile = readFile;
 89 | 
 90 | function readJSON(filePath) {
 91 |   const content = readFile(filePath, "utf8");
 92 |   return content === null ? content : JSON.parse(content);
 93 | }
 94 | 
 95 | exports.readJSON = readJSON;
 96 | 
 97 | function writeFile(filePath, bufferOrString, options) {
 98 |   try {
 99 |     fs.writeFileSync(filePath, bufferOrString, options);
100 |     return true;
101 |   } catch (e) {}
102 |   return false;
103 | }
104 | 
105 | exports.writeFile = writeFile;
106 | 
107 | function writeFileDefer(filePath, content, options) {
108 |   options = Object.assign({}, options);
109 |   pendingWrites[filePath] = { content, options };
110 | 
111 |   if (pendingWriteTimer !== null) {
112 |     return;
113 |   }
114 |   pendingWriteTimer = setImmediate(() => {
115 |     pendingWriteTimer = null;
116 |     Object.keys(pendingWrites).forEach((filePath) => {
117 |       const pending = pendingWrites[filePath];
118 | 
119 |       if (mkdirp(path.dirname(filePath), pending.options.scopePath)) {
120 |         const content = typeof pending.content === "function"
121 |           ? pending.content()
122 |           : pending.content;
123 | 
124 |         if (writeFile(filePath, content, pending.options)) {
125 |           delete pendingWrites[filePath];
126 |         }
127 |       }
128 |     });
129 |   });
130 | }
131 | 
132 | exports.writeFileDefer = writeFileDefer;
133 | 


--------------------------------------------------------------------------------
/node/index.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const runtime = require("../lib/runtime");
 4 | const setDefaults = require("../lib/options").setDefaults;
 5 | const Module = module.constructor;
 6 | 
 7 | Module.prototype.resolve = function (id) {
 8 |   return Module._resolveFilename(id, this);
 9 | };
10 | 
11 | let isDefaultsSet = false;
12 | const parentModule = module.parent || __non_webpack_module__.parent;
13 | 
14 | module.exports = (options) => {
15 |   if (! isDefaultsSet) {
16 |     setDefaults(options);
17 |     isDefaultsSet = true;
18 |   }
19 | };
20 | 
21 | require("./compile-hook.js");
22 | require("./repl-hook.js");
23 | 
24 | runtime.enable(parentModule);
25 | 


--------------------------------------------------------------------------------
/node/pkg-info.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | class PkgInfo {
 4 |   constructor() {
 5 |     this.cache = Object.create(null);
 6 |     this.cachePath = null;
 7 |     this.config = null;
 8 |     this.path = null;
 9 |     this.range = null;
10 |   }
11 | };
12 | 
13 | Object.setPrototypeOf(PkgInfo.prototype, null);
14 | 
15 | module.exports = PkgInfo;
16 | 


--------------------------------------------------------------------------------
/node/repl-hook.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const utils = require("./utils.js");
 4 | 
 5 | const dynModule = module.parent ? module : __non_webpack_module__;
 6 | const rootModule = utils.getRootModule(dynModule);
 7 | 
 8 | if (utils.isREPL(rootModule)) {
 9 |   // Enable import and export statements in the default Node REPL.
10 |   // Custom REPLs can still define their own eval functions that circumvent this
11 |   // compilation step, but that's a feature, not a drawback.
12 |   const compile = require("./caching-compiler.js").compile;
13 |   const runtime = require("../lib/runtime");
14 |   const vm = require("vm");
15 |   const wrapper = require("./wrapper.js");
16 | 
17 |   wrapper.manage(vm, "createScript", function (func, code, options) {
18 |     const pkgInfo = utils.getPkgInfo();
19 |     const wrap = wrapper.find(vm, "createScript", pkgInfo.range);
20 |     return wrap.call(this, func, pkgInfo, code, options);
21 |   });
22 | 
23 |   wrapper.add(vm, "createScript", function (func, pkgInfo, code, options) {
24 |     const cacheFilename = utils.getCacheFileName(null, code, pkgInfo);
25 |     const cacheValue = pkgInfo.cache[cacheFilename];
26 |     code = typeof cacheValue === "string"
27 |       ? cacheValue
28 |       : compile(code, { cacheFilename, pkgInfo });
29 | 
30 |     return func.call(this, code, options);
31 |   });
32 | 
33 |   runtime.enable(rootModule);
34 | }
35 | 


--------------------------------------------------------------------------------
/node/utils.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const createHash = require("crypto").createHash;
  4 | const data = require("./data.js");
  5 | const fs = require("./fs.js");
  6 | const path = require("path");
  7 | const resolveFilename = require("module")._resolveFilename;
  8 | const utils = Object.assign(exports, require("../lib/utils.js"));
  9 | 
 10 | const FastObject = require("../lib/fast-object.js");
 11 | const PkgInfo = require("./pkg-info.js");
 12 | const SemVer = require("semver");
 13 | 
 14 | const DEFAULT_PKG_CONFIG = {
 15 |   "cache-directory": ".reify-cache",
 16 |   parser: void 0,
 17 |   sourceType: void 0
 18 | };
 19 | 
 20 | const hasOwn = Object.prototype.hasOwnProperty;
 21 | const maxSatisfyingCache = new FastObject;
 22 | const reifySemVer = require("./version.js");
 23 | 
 24 | function getReifyRange(json, name) {
 25 |   const entry = json[name];
 26 |   return utils.isObject(entry) && hasOwn.call(entry, "reify")
 27 |     ? SemVer.validRange(entry.reify)
 28 |     : null;
 29 | }
 30 | 
 31 | function getCacheFileName(filePath, cacheKey, pkgInfo) {
 32 |   const ext = typeof filePath === "string" ? path.extname(filePath) : ".js";
 33 | 
 34 |   // Take only the major and minor components of the reify version, so that
 35 |   // we don't invalidate the cache every time a patch version is released.
 36 |   return createHash("sha1")
 37 |     .update(reifySemVer.major + "." + reifySemVer.minor)
 38 |     .update("\0")
 39 |     .update(utils.toString(filePath))
 40 |     .update("\0")
 41 |     .update(utils.toString(cacheKey))
 42 |     .update("\0")
 43 |     .update(JSON.stringify(pkgInfo.config))
 44 |     .update("\0")
 45 |     .digest("hex") + ext;
 46 | }
 47 | 
 48 | exports.getCacheFileName = getCacheFileName;
 49 | 
 50 | function getPkgInfo(dirPath) {
 51 |   dirPath = utils.toString(dirPath);
 52 |   if (dirPath in data.pkgInfo) {
 53 |     return data.pkgInfo[dirPath];
 54 |   }
 55 | 
 56 |   data.pkgInfo[dirPath] = null;
 57 |   if (path.basename(dirPath) === "node_modules") {
 58 |     return null;
 59 |   }
 60 | 
 61 |   const pkgInfo = readPkgInfo(dirPath);
 62 |   if (pkgInfo !== null) {
 63 |     return data.pkgInfo[dirPath] = pkgInfo;
 64 |   }
 65 | 
 66 |   const parentPath = path.dirname(dirPath);
 67 |   if (parentPath !== dirPath) {
 68 |     const pkgInfo = getPkgInfo(parentPath);
 69 |     if (pkgInfo !== null) {
 70 |       return data.pkgInfo[dirPath] = pkgInfo;
 71 |     }
 72 |   }
 73 | 
 74 |   return null;
 75 | }
 76 | 
 77 | exports.getPkgInfo = getPkgInfo;
 78 | 
 79 | function getRootModule(mod) {
 80 |   while (true) {
 81 |     if (mod.parent == null) {
 82 |       return mod;
 83 |     }
 84 |     mod = mod.parent;
 85 |   }
 86 | }
 87 | 
 88 | exports.getRootModule = getRootModule;
 89 | 
 90 | function isREPL(mod) {
 91 |   const root = getRootModule(mod);
 92 |   if (root.filename === null &&
 93 |       root.id === "<repl>" &&
 94 |       root.loaded === false &&
 95 |       root.parent === void 0) {
 96 |     return true;
 97 |   }
 98 |   return false;
 99 | }
100 | 
101 | exports.isREPL = isREPL;
102 | 
103 | function maxSatisfying(versions, range) {
104 |   const cacheKey = versions + "\0" + range;
105 |   if (cacheKey in maxSatisfyingCache) {
106 |     return maxSatisfyingCache[cacheKey];
107 |   }
108 |   return maxSatisfyingCache[cacheKey] = SemVer.maxSatisfying(versions, range);
109 | }
110 | 
111 | exports.maxSatisfying = maxSatisfying;
112 | 
113 | function readPkgInfo(dirPath) {
114 |   const pkgPath = path.join(dirPath, "package.json");
115 |   const pkgJSON = fs.readJSON(pkgPath);
116 | 
117 |   if (pkgJSON === null) {
118 |     return null;
119 |   }
120 | 
121 |   const reify = pkgJSON.reify;
122 | 
123 |   if (reify === false) {
124 |     // An explicit "reify": false property in package.json disables
125 |     // reification even if "reify" is listed as a dependency.
126 |     return null;
127 |   }
128 | 
129 |   const range =
130 |     getReifyRange(pkgJSON, "dependencies") ||
131 |     getReifyRange(pkgJSON, "peerDependencies") ||
132 |     getReifyRange(pkgJSON, "devDependencies");
133 | 
134 |   // Use case: a package.json file may have "reify" in its "devDependencies"
135 |   // object because it expects another package or application to enable
136 |   // reification in production, but needs its own copy of the "reify" package
137 |   // during development. Disabling reification in production when it was enabled
138 |   // in development would be undesired in this case.
139 |   if (range === null) {
140 |     return null;
141 |   }
142 | 
143 |   const config = Object.assign(Object.create(null), DEFAULT_PKG_CONFIG, reify);
144 |   const cacheDir = config["cache-directory"];
145 |   const cachePath = typeof cacheDir === "string" ? path.join(dirPath, cacheDir) : null;
146 |   const cacheFiles = cachePath === null ? null : fs.readdir(cachePath);
147 | 
148 |   const pkgInfo = new PkgInfo;
149 |   pkgInfo.cachePath = cachePath;
150 |   pkgInfo.config = config;
151 |   pkgInfo.path = dirPath;
152 |   pkgInfo.range = range;
153 | 
154 |   const fileCount = cacheFiles === null ? 0 : cacheFiles.length;
155 | 
156 |   for (let i = 0; i < fileCount; ++i) {
157 |     // Later, in Module._extensions[".js"], we'll change the value to the actual
158 |     // contents of the file, but for now we merely register that it exists.
159 |     pkgInfo.cache[cacheFiles[i]] = true;
160 |   }
161 |   return pkgInfo;
162 | }
163 | 
164 | exports.readPkgInfo = readPkgInfo;
165 | 


--------------------------------------------------------------------------------
/node/version.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | const fs = require("./fs.js");
 4 | const path = require("path");
 5 | const pkgPath = path.join(__dirname, "../package.json");
 6 | const SemVer = require("semver");
 7 | 
 8 | module.exports = new SemVer(
 9 |   process.env.REIFY_VERSION || fs.readJSON(pkgPath).version
10 | );
11 | 


--------------------------------------------------------------------------------
/node/wrapper.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const path = require("path");
  4 | const utils = require("./utils.js");
  5 | 
  6 | const FastObject = require("../lib/fast-object.js");
  7 | 
  8 | const hasOwn = Object.prototype.hasOwnProperty;
  9 | const reifySymbol = Symbol.for("__reifyWrapper");
 10 | const reifyVersion = require("./version.js").version;
 11 | 
 12 | function add(object, key, wrapper) {
 13 |   const map = getOrCreateMap(object, key);
 14 | 
 15 |   if (typeof map.wrappers[reifyVersion] !== "function") {
 16 |     map.versions.push(reifyVersion);
 17 |     map.wrappers[reifyVersion] = wrapper;
 18 |   }
 19 | }
 20 | 
 21 | exports.add = add;
 22 | 
 23 | function createMap(object, key) {
 24 |   const map = new FastObject;
 25 |   map.raw = getRaw(object[key]);
 26 |   map.versions = [];
 27 |   map.wrappers = new FastObject;
 28 | 
 29 |   // Store the wrapper map as object[reifySymbol][key] rather than on the
 30 |   // function, so that other code can modify the same property  without
 31 |   // interfering with our wrapper logic.
 32 |   return getOrCreateStore(object)[key] = map;
 33 | }
 34 | 
 35 | exports.createMap = createMap;
 36 | 
 37 | function createStore(object) {
 38 |   return object[reifySymbol] = new FastObject;
 39 | }
 40 | 
 41 | exports.createStore = createStore;
 42 | 
 43 | function find(object, key, range) {
 44 |   const map = getMap(object, key);
 45 |   if (map !== null) {
 46 |     const version = utils.maxSatisfying(map.versions, range);
 47 |     if (version !== null) {
 48 |       return map.wrappers[version];
 49 |     }
 50 |   }
 51 |   return null;
 52 | }
 53 | 
 54 | exports.find = find;
 55 | 
 56 | function getMap(object, key) {
 57 |   const store = getStore(object);
 58 |   return store !== null && key in store
 59 |     ? store[key]
 60 |     : null;
 61 | }
 62 | 
 63 | exports.getMap = getMap;
 64 | 
 65 | function getRaw(func) {
 66 |   return typeof func === "function" && hasOwn.call(func, reifySymbol)
 67 |     ? func[reifySymbol]
 68 |     : func;
 69 | }
 70 | 
 71 | exports.getRaw = getRaw;
 72 | 
 73 | function getStore(object) {
 74 |   return hasOwn.call(object, reifySymbol)
 75 |     ? object[reifySymbol]
 76 |     : null;
 77 | }
 78 | 
 79 | exports.getStore = getStore;
 80 | 
 81 | function getOrCreateStore(object) {
 82 |   const store = getStore(object);
 83 |   return store === null
 84 |     ? createStore(object)
 85 |     : store;
 86 | }
 87 | 
 88 | exports.getOrCreateStore = getOrCreateStore;
 89 | 
 90 | function getOrCreateMap(object, key) {
 91 |   const map = getMap(object, key);
 92 |   return map === null
 93 |     ? createMap(object, key)
 94 |     : map;
 95 | }
 96 | 
 97 | exports.getOrCreateMap = getOrCreateMap;
 98 | 
 99 | function manage(object, key, wrapper) {
100 |   const func = object[key];
101 |   const manager = function () {
102 |     const args = [func];
103 |     const argCount = arguments.length + 1;
104 | 
105 |     for (let i = 1; i < argCount; ++i) {
106 |       args[i] = arguments[i - 1];
107 |     }
108 |     return wrapper.apply(this, args);
109 |   };
110 | 
111 |   manager[reifySymbol] = func;
112 |   object[key] = manager;
113 | }
114 | 
115 | exports.manage = manage;
116 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "reify",
 3 |   "version": "0.22.2",
 4 |   "main": "node/index.js",
 5 |   "browser": "lib/empty.js",
 6 |   "author": "Ben Newman <ben@benjamn.com>",
 7 |   "description": "Enable ECMAScript 2015 modules in Node today. No caveats. Full stop.",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "git+https://github.com/benjamn/reify.git"
11 |   },
12 |   "keywords": [
13 |     "ecmascript",
14 |     "modules",
15 |     "import",
16 |     "export",
17 |     "commonjs",
18 |     "require",
19 |     "exports",
20 |     "node"
21 |   ],
22 |   "license": "MIT",
23 |   "homepage": "https://github.com/benjamn/reify#readme",
24 |   "bugs": {
25 |     "url": "https://github.com/benjamn/reify/issues"
26 |   },
27 |   "engines": {
28 |     "node": ">=4"
29 |   },
30 |   "scripts": {
31 |     "test": "test/run.sh"
32 |   },
33 |   "dependencies": {
34 |     "acorn": "^6.1.1",
35 |     "acorn-dynamic-import": "^4.0.0",
36 |     "magic-string": "^0.25.3",
37 |     "semver": "^5.4.1"
38 |   },
39 |   "devDependencies": {
40 |     "@babel/core": "7.16.0",
41 |     "@babel/parser": "7.16.4",
42 |     "@babel/plugin-transform-runtime": "7.15.0",
43 |     "@babel/preset-env": "7.16.4",
44 |     "lodash": "4.17.21",
45 |     "mocha": "9.1.1",
46 |     "recast": "0.20.5"
47 |   }
48 | }
49 | 


--------------------------------------------------------------------------------
/plugins/babel.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | const assert = require("assert");
  4 | let namespace;
  5 | let ibsPropertyName = "isBlockScoped";
  6 | let types;
  7 | let cache;
  8 | 
  9 | function tryScopedLibDirect() {
 10 |   namespace = require("@babel/types/lib/validators/isBlockScoped");
 11 | 
 12 |   // If the above import succeeded, then we should replace the .default
 13 |   // property of the isBlockScoped module, instead of .isBlockScoped.
 14 |   ibsPropertyName = "default";
 15 | 
 16 |   types = types || require("@babel/types");
 17 |   cache = cache || require("@babel/traverse").default.cache;
 18 | }
 19 | 
 20 | function tryScoped() {
 21 |   namespace = require("@babel/types");
 22 |   types = types || require("@babel/types");
 23 |   cache = cache || require("@babel/traverse").default.cache;
 24 | }
 25 | 
 26 | function tryScopedLib() {
 27 |   namespace = require("@babel/types/lib/validators");
 28 |   types = types || require("@babel/types");
 29 |   cache = cache || require("@babel/traverse").default.cache;
 30 | }
 31 | 
 32 | function tryUnscoped() {
 33 |   namespace = require("babel-types/lib/validators");
 34 |   types = types || require("babel-types");
 35 |   cache = cache || require("babel-traverse").default.cache;
 36 | }
 37 | 
 38 | [tryScopedLibDirect,
 39 |  tryScoped,
 40 |  tryScopedLib,
 41 |  tryUnscoped
 42 | ].some(function (fn) {
 43 |   try {
 44 |     fn();
 45 |   } catch (e) {
 46 |     return false;
 47 |   }
 48 | 
 49 |   const wrapped = namespace[ibsPropertyName];
 50 |   assert.strictEqual(typeof wrapped, "function")
 51 | 
 52 |   // Allow types.isBlockScoped to return true for import-related nodes.
 53 |   const wrapper = namespace[ibsPropertyName] = function (node) {
 54 |     return node &&
 55 |       types.isImportDeclaration(node) ||
 56 |       wrapped.apply(this, arguments);
 57 |   };
 58 | 
 59 |   // The wrapping can fail if namespace[ibsPropertyName] is a non-writable
 60 |   // property (such as a getter function).
 61 |   if (namespace[ibsPropertyName] !== wrapper) {
 62 |     throw new Error(
 63 |       "Unable to patch @babel/types isBlockScoped function"
 64 |     );
 65 |   }
 66 | 
 67 |   return true;
 68 | });
 69 | 
 70 | module.exports = function (context) {
 71 |   const compiler = require("../lib/compiler.js");
 72 |   const transformOptions = {
 73 |     parse: require("../lib/parsers/babel.js").parse
 74 |   };
 75 | 
 76 |   let madeChanges = false;
 77 |   function transform(node) {
 78 |     const result = compiler.transform(node, transformOptions);
 79 |     if (! result.identical) {
 80 |       madeChanges = true;
 81 |       // If the Reify compiler made any changes, invalidate all existing
 82 |       // Scope objects, so that any variable binding changes made by
 83 |       // compiler.transform will be reflected accurately.
 84 |       cache.clearScope();
 85 |     }
 86 |     return result;
 87 |   }
 88 | 
 89 |   return {
 90 |     visitor: {
 91 |       Program: {
 92 |         enter(path) {
 93 |           const code = path.hub.file.code;
 94 |           if (typeof code === "string") {
 95 |             transformOptions.moduleAlias =
 96 |               compiler.makeUniqueId("module", code);
 97 |           }
 98 |           transformOptions.finalCompilationPass = false;
 99 |           Object.assign(transformOptions, this.opts);
100 |           transform(path.node);
101 |         },
102 | 
103 |         exit(path) {
104 |           transformOptions.finalCompilationPass = true;
105 |           const ast = transform(path.node).ast;
106 |           assert.strictEqual(ast.type, "Program");
107 |         }
108 |       }
109 |     }
110 |   };
111 | };
112 | 


--------------------------------------------------------------------------------
/repl/index.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | 
3 | module.exports = require("../node");
4 | 


--------------------------------------------------------------------------------
/test/all-files.js:
--------------------------------------------------------------------------------
 1 | import {
 2 |   join,
 3 |   relative,
 4 |   sep,
 5 | } from "path";
 6 | 
 7 | import {
 8 |   readdirSync,
 9 |   readFileSync,
10 |   statSync,
11 | } from "fs";
12 | 
13 | export const files = Object.create(null);
14 | 
15 | function walk(dir) {
16 |   readdirSync(dir).forEach((item) => {
17 |     const absPath = join(dir, item);
18 |     const stat = statSync(absPath);
19 |     if (stat.isDirectory()) {
20 |       walk(absPath);
21 |     } else if (stat.isFile()) {
22 |       const relPath = relative(__dirname, absPath);
23 |       const relParts = relPath.split(sep);
24 | 
25 |       // Ignore cache files.
26 |       if (relParts[0] === ".cache") {
27 |         return;
28 |       }
29 | 
30 |       // Ignore non-.js files.
31 |       if (! /\.js$/.test(relPath)) {
32 |         return;
33 |       }
34 | 
35 |       files[absPath] = readFileSync(absPath, "utf8");
36 |     }
37 |   });
38 | }
39 | 
40 | walk(__dirname);
41 | 


--------------------------------------------------------------------------------
/test/babel-plugin-tests.js:
--------------------------------------------------------------------------------
  1 | import assert from "assert";
  2 | import { relative } from "path";
  3 | import { transformFromAst } from "@babel/core";
  4 | import { files } from "./all-files.js";
  5 | import { parse } from "../lib/parsers/babel.js";
  6 | import reifyPlugin from "../plugins/babel.js";
  7 | import envPreset from "@babel/preset-env";
  8 | import runtimeTransform from "@babel/plugin-transform-runtime";
  9 | import Visitor from "../lib/visitor.js";
 10 | 
 11 | const filesToTest = Object.create(null);
 12 | const methodNameRegExp =
 13 |   /\bmodule\d*(?:\.link\b|\.export(?:Default)?\b|\["export"\])/;
 14 | 
 15 | Object.keys(files).forEach((absPath) => {
 16 |   const code = files[absPath];
 17 |   const relPath = relative(__dirname, absPath);
 18 | 
 19 |   // These files fail to transform with es2015 preset due to problems
 20 |   // unrelated to the functionality of the Reify Babel plugin.
 21 |   if (relPath === "export/extensions.js" ||
 22 |       relPath === "export/some.js"  ||
 23 |       relPath === "export-tests.js" ||
 24 |       relPath === "import/extensions.js" ||
 25 |       relPath === "import-tests.js" ||
 26 |       relPath === "setter-tests.js" ||
 27 |       relPath.startsWith("output/export-multi-namespace/")) {
 28 |     return;
 29 |   }
 30 | 
 31 |   // Files without import or export tokens don't need to be tested.
 32 |   if (! /\b(?:im|ex)port\b/.test(code)) {
 33 |     return;
 34 |   }
 35 | 
 36 |   filesToTest[relPath] = code;
 37 | });
 38 | 
 39 | function fail(path) {
 40 |   throw new Error("unexpected node of type " + path.getNode().type);
 41 | }
 42 | 
 43 | class ImportExportChecker extends Visitor {
 44 |   visitImportDeclaration(path) { fail(path) }
 45 |   visitExportAllDeclaration(path) { fail(path) }
 46 |   visitExportDefaultDeclaration(path) { fail(path) }
 47 |   visitExportNamedDeclaration(path) { fail(path) }
 48 | }
 49 | 
 50 | describe("reify/plugins/babel", () => {
 51 |   it("should not double-wrap module.runSetters expressions", () => {
 52 |     const code = [
 53 |       'import x from "./y";',
 54 |       'export let z = x + 1;',
 55 |       'const { a, ...rest } = { a: x };',
 56 |       'eval("++z");',
 57 |     ].join("\n");
 58 | 
 59 |     function check(plugins) {
 60 |       const ast = parse(code);
 61 |       delete ast.tokens;
 62 |       const result = transformFromAst(ast, code, {
 63 |         plugins: plugins,
 64 |         presets: [
 65 |           [envPreset, {
 66 |             targets: {
 67 |               ie: 11
 68 |             }
 69 |           }]
 70 |         ]
 71 |       });
 72 |       assert.strictEqual(
 73 |         result.code.split("runSetters").length, 2,
 74 |         result.code
 75 |       );
 76 |     }
 77 | 
 78 |     check([
 79 |       reifyPlugin,
 80 |       runtimeTransform,
 81 |     ]);
 82 | 
 83 |     check([
 84 |       runtimeTransform,
 85 |       reifyPlugin,
 86 |     ]);
 87 |   });
 88 | 
 89 |   function check(code, options) {
 90 |     const ast = parse(code);
 91 |     delete ast.tokens;
 92 |     const result = transformFromAst(ast, code, options);
 93 |     assert.ok(methodNameRegExp.test(result.code), result.code);
 94 |     new ImportExportChecker().visit(parse(result.code));
 95 |     return result;
 96 |   }
 97 | 
 98 |   Object.keys(filesToTest).forEach((relPath) => {
 99 |     const code = filesToTest[relPath];
100 | 
101 |     const presets = [
102 |       [envPreset, {
103 |         targets: {
104 |           ie: 11
105 |         }
106 |       }]
107 |     ];
108 | 
109 |     const pluginsReifyFirst = [
110 |       [reifyPlugin, {
111 |         generateLetDeclarations: true
112 |       }],
113 |       runtimeTransform,
114 |     ];
115 | 
116 |     const pluginsReifyLast = [
117 |       [reifyPlugin, {
118 |         generateLetDeclarations: true
119 |       }],
120 |       runtimeTransform,
121 |     ];
122 | 
123 |     it(`compiles ${relPath}`, () => {
124 |       check(code, { plugins: pluginsReifyFirst });
125 |       check(code, { plugins: pluginsReifyLast });
126 |     });
127 | 
128 |     it(`compiles ${relPath} with es2015`, () => {
129 |       check(code, { plugins: pluginsReifyFirst, presets });
130 |       check(code, { plugins: pluginsReifyLast, presets });
131 |     });
132 |   });
133 | });
134 | 


--------------------------------------------------------------------------------
/test/cjs/bridge.js:
--------------------------------------------------------------------------------
1 | module.link("../misc/live", { "*": "*+" });
2 | 


--------------------------------------------------------------------------------
/test/cjs/export-default-property.js:
--------------------------------------------------------------------------------
1 | Object.defineProperty(exports, "default", {
2 |   value: "oyez",
3 |   enumerable: true,
4 |   writable: false,
5 |   configurable: true
6 | });
7 | 


--------------------------------------------------------------------------------
/test/cjs/module-exports-esModule.js:
--------------------------------------------------------------------------------
1 | module.exports = { __esModule: true };
2 | 


--------------------------------------------------------------------------------
/test/cjs/module-exports-function.js:
--------------------------------------------------------------------------------
1 | module.exports = function () {
2 |   return "ok";
3 | };
4 | 


--------------------------------------------------------------------------------
/test/cjs/module-exports-null.js:
--------------------------------------------------------------------------------
1 | module.exports = null;
2 | 


--------------------------------------------------------------------------------
/test/cjs/module-exports-object.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   a: 1,
3 |   b: 2,
4 |   c: 3
5 | };
6 | 


--------------------------------------------------------------------------------
/test/compiler-tests.js:
--------------------------------------------------------------------------------
  1 | import assert from "assert";
  2 | import { compile } from "../lib/compiler.js";
  3 | 
  4 | function isUseStrictExprStmt(stmt) {
  5 |   return stmt.type === "ExpressionStatement" &&
  6 |     stmt.expression.value === "use strict";
  7 | }
  8 | 
  9 | describe("compiler", () => {
 10 |   it("should not get confused by string literals", () => {
 11 |     assert.strictEqual(
 12 |       'a; import b from "c"; d',
 13 |       "a; import b " + 'from "c"; d'
 14 |     );
 15 | 
 16 |     assert.strictEqual(
 17 |       'a; export {a} from "a"; b;',
 18 |       "a; export {a" + '} from "a"; b;'
 19 |     );
 20 |   });
 21 | 
 22 |   it("should not be enabled for nested node_modules", () => {
 23 |     let error;
 24 | 
 25 |     try {
 26 |       import "disabled";
 27 |     } catch (e) {
 28 |       error = e;
 29 |     }
 30 | 
 31 |     assert.ok(error instanceof SyntaxError);
 32 |     assert.ok(
 33 |       /unexpected/i.test(error.message) ||
 34 |       /Cannot use import /i.test(error.message),
 35 |       error,
 36 |     );
 37 |   });
 38 | 
 39 |   it("should be enabled for packages that depend on reify", () => {
 40 |     import a from "enabled";
 41 |     assert.strictEqual(a, assert);
 42 |   });
 43 | 
 44 |   it("should preserve line numbers", () => {
 45 |     import check from "./compiler/lines.js";
 46 |     check();
 47 |   });
 48 | 
 49 |   it('should not hoist above "use strict"', () => {
 50 |     import { check } from "./compiler/strict";
 51 |     assert.strictEqual(check(), true);
 52 |   });
 53 | 
 54 |   it("should transform AST when options.ast truthy", () => {
 55 |     function isVarDecl(node, names) {
 56 |       assert.strictEqual(node.type, "VariableDeclaration");
 57 |       assert.deepEqual(node.declarations.map((decl) => decl.id.name), names);
 58 |     }
 59 | 
 60 |     function isCallExprStmt(node, objectName, propertyName) {
 61 |       assert.strictEqual(node.type, "ExpressionStatement");
 62 |       assert.strictEqual(node.expression.type, "CallExpression");
 63 |       assert.strictEqual(
 64 |         node.expression.callee.object.name, objectName);
 65 |       assert.strictEqual(
 66 |         node.expression.callee.property.name, propertyName);
 67 |     }
 68 | 
 69 |     const code = [
 70 |       "console.log(foo, bar);",
 71 |       'import foo from "./foo"',
 72 |       'import bar from "./bar"',
 73 |       "export default foo + bar;"
 74 |     ].join("\n");
 75 | 
 76 |     const result = compile(code, { ast: true });
 77 |     let ast = result.ast;
 78 | 
 79 |     if (ast.type === "File") {
 80 |       ast = ast.program;
 81 |     }
 82 | 
 83 |     assert.strictEqual(ast.type, "Program");
 84 | 
 85 |     const firstIndex = isUseStrictExprStmt(ast.body[0]) ? 1 : 0;
 86 |     assert.strictEqual(ast.body.length - firstIndex, 6);
 87 | 
 88 |     isVarDecl(ast.body[firstIndex + 0], ["foo"]);
 89 |     isCallExprStmt(ast.body[firstIndex + 1], "module", "link");
 90 |     isVarDecl(ast.body[firstIndex + 2], ["bar"]);
 91 |     isCallExprStmt(ast.body[firstIndex + 3], "module", "link");
 92 |     isCallExprStmt(ast.body[firstIndex + 4], "console", "log");
 93 |     isCallExprStmt(ast.body[firstIndex + 5], "module", "exportDefault");
 94 |   });
 95 | 
 96 |   it("should respect options.enforceStrictMode", () => {
 97 |     const source = 'import "a"';
 98 | 
 99 |     const withoutStrict = compile(source, {
100 |       enforceStrictMode: false
101 |     }).code;
102 | 
103 |     assert.ok(! withoutStrict.startsWith('"use strict"'));
104 | 
105 |     const withStrict = compile(source, {
106 |       enforceStrictMode: true
107 |     }).code;
108 | 
109 |     assert.ok(withStrict.startsWith('"use strict"'));
110 | 
111 |     // No options.enforceStrictMode is the same as
112 |     // { enforceStrictMode: true }.
113 |     const defaultStrict = compile(
114 |       source
115 |     ).code;
116 | 
117 |     assert.ok(defaultStrict.startsWith('"use strict"'));
118 |   });
119 | 
120 |   it("should always generate arrow functions", () => {
121 |     assert.ok(compile([
122 |       'import def from "mod"',
123 |       "export { def as x }"
124 |     ].join("\n")).code.includes("=>"));
125 |   });
126 | 
127 |   it("should respect options.generateLetDeclarations", () => {
128 |     const source = 'import foo from "./foo"';
129 | 
130 |     const withLet = compile(source, {
131 |       generateLetDeclarations: true
132 |     }).code;
133 | 
134 |     assert.ok(withLet.startsWith('"use strict";let foo;'));
135 | 
136 |     const withoutLet = compile(source, {
137 |       generateLetDeclarations: false
138 |     }).code;
139 | 
140 |     assert.ok(withoutLet.startsWith('"use strict";var foo;'));
141 | 
142 |     // No options.generateLetDeclarations is the same as
143 |     // { generateLetDeclarations: false }.
144 |     const defaultLet = compile(
145 |       source
146 |     ).code;
147 | 
148 |     assert.ok(defaultLet.startsWith('"use strict";var foo;'));
149 |   });
150 | 
151 |   it("should respect options.avoidModernSyntax", () => {
152 |     const source = [
153 |       'import foo from "./foo";',
154 |       'export { foo as bar };',
155 |       'const fooPlusOne = foo + 1;',
156 |       'export default fooPlusOne;',
157 |     ].join("\n");
158 | 
159 |     const legacy = compile(source, {
160 |       avoidModernSyntax: true
161 |     }).code;
162 | 
163 |     assert.strictEqual(legacy, [
164 |       '"use strict";module.export({bar:function(){return foo}});var foo;module.link("./foo",{default:function(v){foo=v}},0);',
165 |       "",
166 |       "const fooPlusOne = foo + 1;",
167 |       "module.exportDefault(fooPlusOne);",
168 |     ].join("\n"));
169 | 
170 |     const legacyIgnoresLetOption = compile(source, {
171 |       avoidModernSyntax: true,
172 |       // Ignored because let declarations are "modern" syntax.
173 |       generateLetDeclarations: true
174 |     }).code;
175 |     assert.strictEqual(legacy, legacyIgnoresLetOption);
176 | 
177 |     const modernImplicit = compile(source, {
178 |       generateLetDeclarations: true
179 |     }).code;
180 | 
181 |     const modernExplicit = compile(source, {
182 |       generateLetDeclarations: true,
183 |       avoidModernSyntax: false
184 |     }).code;
185 | 
186 |     assert.strictEqual(modernImplicit, modernExplicit);
187 |     assert.strictEqual(modernExplicit, [
188 |       '"use strict";module.export({bar:()=>foo});let foo;module.link("./foo",{default(v){foo=v}},0);',
189 |       "",
190 |       "const fooPlusOne = foo + 1;",
191 |       "module.exportDefault(fooPlusOne);",
192 |     ].join("\n"));
193 | 
194 |     const modernWithoutLet = compile(source, {
195 |       avoidModernSyntax: false
196 |     }).code;
197 | 
198 |     assert.strictEqual(modernWithoutLet, [
199 |       '"use strict";module.export({bar:()=>foo});var foo;module.link("./foo",{default(v){foo=v}},0);',
200 |       "",
201 |       "const fooPlusOne = foo + 1;",
202 |       "module.exportDefault(fooPlusOne);",
203 |     ].join("\n"));
204 |   });
205 | 
206 |   it("should allow pre-parsed ASTs via options.parse", () => {
207 |     import { parse } from "../lib/parsers/default.js";
208 | 
209 |     const code = 'import foo from "./foo"';
210 |     const ast = parse(code);
211 |     const illegal = code.replace(/\bfoo\b/g, "+@#");
212 |     const result = compile(illegal, {
213 |       generateLetDeclarations: true,
214 |       // If you really want to avoid parsing, you can provide an
215 |       // options.parse function that returns whatever AST you like.
216 |       parse: () => ast
217 |     });
218 | 
219 |     assert.strictEqual(result.ast, null);
220 |     assert.ok(result.code.startsWith('"use strict";let foo'));
221 |     assert.ok(result.code.includes('"./+@#"'));
222 |   });
223 | 
224 |   it("should respect options.sourceType", () => {
225 |     const source = "1+2;";
226 | 
227 |     const moduleType = compile(source, {
228 |       sourceType: "module"
229 |     }).code;
230 | 
231 |     assert.ok(moduleType.startsWith('"use strict"'), moduleType);
232 | 
233 |     const unambiguousAsCJS = compile(source, {
234 |       sourceType: "unambiguous"
235 |     }).code;
236 | 
237 |     assert.ok(! unambiguousAsCJS.startsWith('"use strict"'), unambiguousAsCJS);
238 | 
239 |     const unambiguousAsESM = compile('import "a"\n' + source, {
240 |       sourceType: "unambiguous"
241 |     }).code;
242 | 
243 |     assert.ok(unambiguousAsESM.startsWith('"use strict"'), unambiguousAsESM);
244 | 
245 |     const scriptType = compile('import "a"\n' + source, {
246 |       sourceType: "script"
247 |     }).code;
248 | 
249 |     assert.ok(scriptType.startsWith('"use strict";module.link("a")'), scriptType);
250 | 
251 |     // No options.sourceType is the same as
252 |     // { sourceType: "unambiguous" }.
253 |     const defaultType = compile(
254 |       source
255 |     ).code;
256 | 
257 |     assert.ok(! defaultType.startsWith('"use strict"'), defaultType);
258 |   });
259 | 
260 |   it("should transform default export declaration to expression", () => {
261 |     function parse(code) {
262 |       const result = compile(code, { ast: true });
263 |       let ast = result.ast;
264 | 
265 |       if (ast.type === "File") {
266 |         ast = ast.program;
267 |       }
268 | 
269 |       assert.strictEqual(ast.type, "Program");
270 | 
271 |       return ast;
272 |     }
273 | 
274 |     const anonCode = "export default class {}";
275 |     const anonAST = parse(anonCode);
276 | 
277 |     const anonFirstIndex =
278 |       isUseStrictExprStmt(anonAST.body[0]) ? 1 : 0;
279 | 
280 |     assert.strictEqual(anonAST.body.length - anonFirstIndex, 1);
281 |     assert.strictEqual(
282 |       anonAST.body[anonFirstIndex].expression.arguments[0].type,
283 |       "ClassExpression"
284 |     );
285 | 
286 |     const namedCode = "export default class C {}";
287 |     const namedAST = parse(namedCode);
288 | 
289 |     const namedFirstIndex =
290 |       isUseStrictExprStmt(namedAST.body[0]) ? 1 : 0;
291 | 
292 |     assert.strictEqual(namedAST.body.length - namedFirstIndex, 2);
293 |     assert.strictEqual(
294 |       namedAST.body[namedFirstIndex + 1].type,
295 |       "ClassDeclaration"
296 |     );
297 |   });
298 | 
299 |   it("should not get confused by shebang", () => {
300 |     const code = [
301 |       "#!/usr/bin/env node -r reify",
302 |       'import foo from "./foo"',
303 |     ].join("\n");
304 | 
305 |     const withShebang = compile(code).code;
306 |     assert.ok(withShebang.startsWith('"use strict";var foo'));
307 |   });
308 | 
309 |   it("should preserve crlf newlines", () => {
310 |     const code = [
311 |       "import {",
312 |       "  strictEqual,",
313 |       "  // blank line",
314 |       "  deepEqual",
315 |       "}",
316 |       'from "assert";'
317 |     ].join("\r\n");
318 | 
319 |     const result = compile(code).code;
320 |     assert.ok(result.endsWith("\r\n".repeat(5)));
321 |   });
322 | 
323 |   it("should compile dynamic import(...)", () => {
324 |     function check(optionValue, source, expected) {
325 |       assert.strictEqual(
326 |         compile(source, {
327 |           enforceStrictMode: false,
328 |           dynamicImport: optionValue
329 |         }).code,
330 |         expected
331 |       );
332 |     }
333 | 
334 |     check(
335 |       void 0,
336 |       "import(x)",
337 |       "import(x)"
338 |     );
339 | 
340 |     check(
341 |       false,
342 |       "import(x)",
343 |       "import(x)"
344 |     );
345 | 
346 |     check(
347 |       true,
348 |       "import(x)",
349 |       "module.dynamicImport(x)"
350 |     );
351 | 
352 |     check(
353 |       "dynamicImport",
354 |       "import(x)",
355 |       "module.dynamicImport(x)"
356 |     );
357 | 
358 |     check(
359 |       "_import",
360 |       "import(x)",
361 |       "module._import(x)"
362 |     );
363 | 
364 |     check(
365 |       true,
366 |       "import (x)",
367 |       "module.dynamicImport (x)"
368 |     );
369 | 
370 |     check(
371 |       true,
372 |       [
373 |         "import(function () {",
374 |         "  return getId();",
375 |         "}())",
376 |       ].join("\n"),
377 |       [
378 |         "module.dynamicImport(function () {",
379 |         "  return getId();",
380 |         "}())",
381 |       ].join("\n")
382 |     );
383 | 
384 |     check(true, [
385 |       "import(",
386 |       "  id",
387 |       ")",
388 |     ].join("\n"), [
389 |       "module.dynamicImport(",
390 |       "  id",
391 |       ")",
392 |     ].join("\n"));
393 | 
394 |     check(
395 |       true,
396 |       "import(`\nid\n`)",
397 |       "module.dynamicImport(`\nid\n`)"
398 |     );
399 |   });
400 | });
401 | 


--------------------------------------------------------------------------------
/test/compiler/lines.js:
--------------------------------------------------------------------------------
 1 | import {
 2 |   strictEqual,
 3 |   // blank line
 4 |   deepEqual,
 5 | }
 6 | from "assert";
 7 | 
 8 | export
 9 | default
10 | 
11 | function check()
12 | 
13 | {
14 |   const error = new Error; // Line 14
15 |   const line = +error.stack.split("\n")[1].split(":")[1];
16 |   strictEqual(line, 14);
17 | }
18 | 


--------------------------------------------------------------------------------
/test/compiler/strict.js:
--------------------------------------------------------------------------------
 1 | export function check() {
 2 |   "use strict"
 3 | 
 4 |   import { strictEqual } from "assert";
 5 |   import { a, b, c } from "../misc/abc";
 6 | 
 7 |   strictEqual(a, "a");
 8 |   strictEqual(b, "b");
 9 |   strictEqual(c, "c");
10 | 
11 |   // Returns true iff the current function is strict.
12 |   return function () {
13 |     return ! this;
14 |   }();
15 | };
16 | 


--------------------------------------------------------------------------------
/test/default-expression.js:
--------------------------------------------------------------------------------
1 | let count = 0;
2 | 
3 | // This default expression will evaluate to 0 if the parentheses are
4 | // mistakenly stripped away.
5 | export default (count++, count);
6 | 


--------------------------------------------------------------------------------
/test/default-function.js:
--------------------------------------------------------------------------------
 1 | import { strictEqual } from "assert";
 2 | 
 3 | const obj = {};
 4 | 
 5 | export default function f() {
 6 |   return obj;
 7 | }
 8 | 
 9 | export function check(g) {
10 |   strictEqual(f, g);
11 |   strictEqual(f(), obj);
12 |   strictEqual(g(), obj);
13 | }
14 | 


--------------------------------------------------------------------------------
/test/export-tests.js:
--------------------------------------------------------------------------------
  1 | import assert from "assert";
  2 | import { Script } from "vm";
  3 | 
  4 | let canUseClasses = false;
  5 | let canUseDestructuring = false;
  6 | let canUseLetConst = false;
  7 | const canUseExportExtensions = process.env.REIFY_PARSER !== "babel";
  8 | 
  9 | try {
 10 |   // Test if Node supports class syntax.
 11 |   new Script("class A {}");
 12 |   canUseClasses = true;
 13 | } catch (e) {}
 14 | 
 15 | try {
 16 |   // Test if Node supports destructuring declarations.
 17 |   new Script("const { x, y } = {}");
 18 |   canUseDestructuring = true;
 19 | } catch (e) {}
 20 | 
 21 | try {
 22 |   // Test if Node supports block declaration syntax.
 23 |   new Script("let x; const y = 1");
 24 |   canUseLetConst = true;
 25 | } catch (e) {}
 26 | 
 27 | describe("export declarations", () => {
 28 |   it("should allow * exports", () => {
 29 |     import def, {
 30 |       a, b, c as d,
 31 |     } from "./export/all.js";
 32 | 
 33 |     assert.strictEqual(a, "a");
 34 |     assert.strictEqual(b, "b");
 35 |     assert.strictEqual(d, "c");
 36 |     assert.strictEqual(def, "default");
 37 |   });
 38 | 
 39 |   it("should allow re-exporting import * alongside export *", () => {
 40 |     import {
 41 |       Abc, d, e, f,
 42 |     } from "./export/all-multiple.js";
 43 | 
 44 |     assert.strictEqual(Abc.a, "a");
 45 |     assert.strictEqual(Abc.b, "b");
 46 |     assert.strictEqual(Abc.c, "c");
 47 |     assert.strictEqual(d, "d");
 48 |     assert.strictEqual(e, "e");
 49 |     assert.strictEqual(f, "f");
 50 |   });
 51 | 
 52 |   it("should tolerate mutual * exports", () => {
 53 |     import { a as aa, b as ab } from "./export/all-mutual-a.js";
 54 |     import { a as ba, b as bb } from "./export/all-mutual-b.js";
 55 | 
 56 |     assert.strictEqual(aa, "a");
 57 |     assert.strictEqual(ab, "b");
 58 |     assert.strictEqual(ba, "a");
 59 |     assert.strictEqual(bb, "b");
 60 |   });
 61 | 
 62 |   it("should allow specifiers that shadow Object.prototype", () => {
 63 |     import {
 64 |       constructor,
 65 |       hasOwnProperty,
 66 |       toString,
 67 |       valueOf
 68 |     } from "./export/shadowed.js";
 69 | 
 70 |     assert.strictEqual(constructor, "a");
 71 |     assert.strictEqual(hasOwnProperty, "b");
 72 |     assert.strictEqual(toString, "c");
 73 |     assert.strictEqual(valueOf, "d");
 74 |   });
 75 | 
 76 |   it("should allow named re-exports", () => {
 77 |     import { a, c, v, si } from "./export/some.js";
 78 | 
 79 |     assert.strictEqual(a, "a");
 80 |     assert.strictEqual(c(), "c");
 81 |     assert.strictEqual(v, "b");
 82 |     assert.strictEqual(si, "c");
 83 |   });
 84 | 
 85 |   it("should be able to contain import declarations", () => {
 86 |     import { outer } from "./export/nested";
 87 |     assert.deepEqual(outer(), ["a", "b", "c"]);
 88 |   });
 89 | 
 90 |   it("should support default declarations", () => {
 91 |     import g, { check } from "./export/default-function";
 92 |     check(g);
 93 |   });
 94 | 
 95 |   it("should support default expressions", () => {
 96 |     import count from "./export/default-expression";
 97 |     assert.strictEqual(count, 1);
 98 |   });
 99 | 
100 |   it("should be able to invoke setters later", (done) => {
101 |     import def, {
102 |       val,
103 |       exportAgain,
104 |       exportYetAgain,
105 |       oneLastExport
106 |     } from "./export/later";
107 | 
108 |     assert.strictEqual(def, "default-1");
109 |     assert.strictEqual(val, "value-1");
110 | 
111 |     exportAgain();
112 |     assert.strictEqual(def, "default-1");
113 |     assert.strictEqual(val, "value-2");
114 | 
115 |     setImmediate(() => {
116 |       oneLastExport();
117 |       assert.strictEqual(def, "default-1");
118 |       assert.strictEqual(val, "value-3");
119 |       done();
120 |     });
121 |   });
122 | 
123 |   it("should support all default syntax", () => {
124 |     import number from "./export/default/number";
125 |     assert.strictEqual(number, 42);
126 | 
127 |     import object from "./export/default/object";
128 |     assert.deepEqual(object, { foo: 42 });
129 | 
130 |     import array from "./export/default/array";
131 |     assert.deepEqual(array, [1, 2, 3]);
132 | 
133 |     import func from "./export/default/function";
134 |     assert.strictEqual(func(), func);
135 | 
136 |     import anonFunc from "./export/default/anon-function";
137 |     assert.strictEqual(anonFunc(3), 4);
138 | 
139 |     import ident from "./export/default/identifier";
140 |     assert.strictEqual(ident, 42);
141 | 
142 |     if (canUseClasses) {
143 |       import Anon from "./export/default/anon-class";
144 |       assert.strictEqual(new Anon(1234).value, 1234);
145 | 
146 |       import Named from "./export/default/named-class";
147 |       assert.strictEqual(new Named(56, 78).sum, 56 + 78);
148 |     }
149 |   });
150 | 
151 |   it("should support basic declaration syntax", () => {
152 |     import { a, b, c, d } from "./export/declarations/basic";
153 | 
154 |     assert.strictEqual(a, 1);
155 |     assert.strictEqual(b(), d);
156 |     assert.strictEqual(c, "c");
157 |     assert.strictEqual(d(), b);
158 |   });
159 | 
160 |   (canUseLetConst ? it : xit)(
161 |     "should support block declaration syntax", () => {
162 |     import { a, b, c } from "./export/declarations/block";
163 | 
164 |     assert.strictEqual(a, 1);
165 |     assert.strictEqual(b, 2);
166 |     assert.strictEqual(c, 3);
167 |   });
168 | 
169 |   it("should support all named export syntax", () => {
170 |     const exp = require("./export/names");
171 | 
172 |     assert.strictEqual(exp.foo, "foo");
173 |     assert.strictEqual(exp.bar, "bar");
174 |     assert.strictEqual(exp.baz, "baz");
175 |     assert.strictEqual(exp.foo2, "foo");
176 |     assert.strictEqual(exp.foo3, "foo");
177 |     assert.strictEqual(exp.baz2, "baz");
178 |     assert.strictEqual(exp.default, "foo");
179 | 
180 |     import foo from "./export/names";
181 |     assert.strictEqual(foo, "foo");
182 |   });
183 | 
184 |   it("should tolerate one-to-many renamed exports", () => {
185 |     import { x, y, append } from "./export/renamed";
186 | 
187 |     assert.strictEqual(x, y);
188 |     assert.strictEqual(x, "a");
189 | 
190 |     assert.strictEqual(append("b"), "ab");
191 | 
192 |     assert.strictEqual(x, y);
193 |     assert.strictEqual(x, "ab");
194 | 
195 |     assert.strictEqual(append("c"), "abc");
196 | 
197 |     assert.strictEqual(x, y);
198 |     assert.strictEqual(x, "abc");
199 |   });
200 | 
201 |   it("should support all export-from syntax", () => {
202 |     import def, { a, b, c, ay, bee, foo } from "./export/from";
203 | 
204 |     assert.strictEqual(def, "a");
205 |     assert.strictEqual(a, "a");
206 |     assert.strictEqual(b, "b");
207 |     assert.strictEqual(c, "c");
208 |     assert.strictEqual(ay, "a");
209 |     assert.strictEqual(bee, "b");
210 |     assert.deepEqual(foo, { a: "a", b: "b", c: "c" });
211 |   });
212 | 
213 |   it("should support export { default } from ... syntax", () => {
214 |     import object from "./export/default/from";
215 |     assert.deepEqual(object, { foo: 42 });
216 |   });
217 | 
218 |   it("should support switch-case nested imports", () => {
219 |     for (let i = 0; i < 2; ++i) {
220 |       switch (i) {
221 |       case 0:
222 |         import { a as xa } from "./misc/abc";
223 |         assert.strictEqual(xa, "a");
224 |         break;
225 |       case 1:
226 |         import { b as xb } from "./misc/abc";
227 |         assert.strictEqual(xb, "b");
228 |         break;
229 |       }
230 |     }
231 |   });
232 | 
233 |   (canUseDestructuring ? it : xit)(
234 |     "should support destructuring declarations", () => {
235 |     import { a, c as b, d, x, y, rest } from "./export/destructuring.js";
236 | 
237 |     assert.strictEqual(a, "a");
238 |     assert.strictEqual(b, "b");
239 |     assert.strictEqual(d, 1234);
240 |     assert.strictEqual(x, 1);
241 |     assert.strictEqual(y, 2);
242 |     assert.deepEqual(rest, [a, b, d]);
243 |   });
244 | 
245 |   (canUseDestructuring ? it : xit)(
246 |   "should invoke destructuring setters later", () => {
247 |     import { x, y, swap } from "./export/swap-later.js";
248 | 
249 |     assert.strictEqual(x, 1);
250 |     assert.strictEqual(y, 2);
251 |     swap();
252 |     assert.strictEqual(x, 2);
253 |     assert.strictEqual(y, 1);
254 |   });
255 | 
256 |   (canUseDestructuring ? it : xit)(
257 |   "should not crash on array patterns with holes", () => {
258 |     import { a, b, update } from "./export/array-pattern-holes.js";
259 | 
260 |     assert.strictEqual(a, 1);
261 |     assert.strictEqual(b, 2);
262 |     assert.strictEqual(update(3, 4, 5), 8);
263 |     assert.strictEqual(a, 3);
264 |     assert.strictEqual(b, 5);
265 |   });
266 | 
267 |   (canUseExportExtensions ? it : xit)(
268 |   "should support export extensions", () => {
269 |     import {
270 |       def1, def2, def3, def4,
271 |       ns1, ns2, ns3, ns4,
272 |       a, b, c, d, e
273 |     } from "./export/extensions";
274 | 
275 |     import def, {
276 |       a as _a,
277 |       b as _b,
278 |       b as _c,
279 |       c as _d,
280 |       c as _e,
281 |     } from "./misc/abc";
282 | 
283 |     assert.strictEqual(def, def1);
284 |     assert.strictEqual(def, def2);
285 |     assert.strictEqual(def, def3);
286 |     assert.strictEqual(def, def4);
287 | 
288 |     function checkNS(ns) {
289 |       assert.strictEqual(ns.a, def.a);
290 |       assert.strictEqual(ns.b, def.b);
291 |       assert.strictEqual(ns.c, def.c);
292 |       assert.notStrictEqual(ns, def);
293 |     }
294 | 
295 |     checkNS(ns1);
296 |     checkNS(ns2);
297 |     checkNS(ns3);
298 |     checkNS(ns4);
299 | 
300 |     assert.strictEqual(a, _a);
301 |     assert.strictEqual(b, _b);
302 |     assert.strictEqual(c, _c);
303 |     assert.strictEqual(d, _d);
304 |     assert.strictEqual(e, _e);
305 |   });
306 | 
307 |   it("does not reorder export...from imports", () => {
308 |     import { aName, bName, cName } from "./export/from-ordering.js";
309 |     assert.strictEqual(aName, "from-ordering-a.js");
310 |     assert.strictEqual(bName, "from-ordering-b.js");
311 |     assert.strictEqual(cName, "from-ordering-c.js");
312 | 
313 |     import { names } from "./export/from-ordering-common.js";
314 |     assert.deepEqual(names, [
315 |       "from-ordering-a.js",
316 |       "from-ordering-b.js",
317 |       "from-ordering-c.js",
318 |     ]);
319 |   });
320 | 
321 |   it("should be tolerant of exporting undeclared identifiers", () => {
322 |     import { GlobalArray } from "./undeclared-export.js";
323 |     assert.strictEqual(GlobalArray, Array);
324 |   });
325 | });
326 | 


--------------------------------------------------------------------------------
/test/export/all-lodash.js:
--------------------------------------------------------------------------------
1 | export * from "lodash";
2 | 


--------------------------------------------------------------------------------
/test/export/all-multiple.js:
--------------------------------------------------------------------------------
1 | import * as n from "../misc/abc";
2 | export * from "./def";
3 | export { n as Abc };
4 | 


--------------------------------------------------------------------------------
/test/export/all-mutual-a.js:
--------------------------------------------------------------------------------
1 | export * from "./all-mutual-b.js";
2 | export const a = "a";
3 | 


--------------------------------------------------------------------------------
/test/export/all-mutual-b.js:
--------------------------------------------------------------------------------
1 | export * from "./all-mutual-a.js";
2 | export const b = "b";
3 | 


--------------------------------------------------------------------------------
/test/export/all.js:
--------------------------------------------------------------------------------
1 | export default "default";
2 | export * from "../misc/abc";
3 | 


--------------------------------------------------------------------------------
/test/export/array-pattern-holes.js:
--------------------------------------------------------------------------------
1 | export let a = 1, b = 2;
2 | export function update() {
3 |   [a, /*hole*/, b] = Array.prototype.slice.call(arguments);
4 |   return a + b;
5 | }
6 | 


--------------------------------------------------------------------------------
/test/export/class.js:
--------------------------------------------------------------------------------
1 | import assert from "assert";
2 | 
3 | export class H {
4 |   constructor(a, b) {
5 |     assert.ok(this instanceof H);
6 |     this.sum = a + b;
7 |   }
8 | };
9 | 


--------------------------------------------------------------------------------
/test/export/common.js:
--------------------------------------------------------------------------------
 1 | import { strictEqual } from "assert";
 2 | 
 3 | // Setting module.exports should still define the default exported value
 4 | // if there are no actual ExportDefaultDeclaration nodes.
 5 | module.exports = "pure CommonJS";
 6 | 
 7 | // The import statement above should have been compiled to a
 8 | // module.importSync call, which sets exports[Symbol.for("__esModule")] = true.
 9 | strictEqual(exports[Symbol.for("__esModule")], true);
10 | 


--------------------------------------------------------------------------------
/test/export/cycle-a.js:
--------------------------------------------------------------------------------
 1 | function fun() {
 2 |   return true;
 3 | }
 4 | 
 5 | import { callFun } from "./cycle-b";
 6 | 
 7 | export default callFun();
 8 | 
 9 | export { fun };
10 | 


--------------------------------------------------------------------------------
/test/export/cycle-b.js:
--------------------------------------------------------------------------------
1 | import { fun } from "./cycle-a";
2 | 
3 | export function callFun() {
4 |   return fun();
5 | }
6 | 


--------------------------------------------------------------------------------
/test/export/declarations.js:
--------------------------------------------------------------------------------
1 | export const a = 1;
2 | export const b = function () {};
3 | export let c; // lazy initialization
4 | export function g() {};
5 | c = "c";
6 | 


--------------------------------------------------------------------------------
/test/export/declarations/basic.js:
--------------------------------------------------------------------------------
 1 | export const a = 1;
 2 | export const b = function () {
 3 |   return d;
 4 | };
 5 | export let c; // lazy initialization
 6 | export function d() {
 7 |   return b;
 8 | };
 9 | 
10 | c = "c";
11 | 


--------------------------------------------------------------------------------
/test/export/declarations/block.js:
--------------------------------------------------------------------------------
1 | export let a = 1;
2 | export let b; // lazy initialization
3 | export const c = 3;
4 | b = 2;
5 | 


--------------------------------------------------------------------------------
/test/export/def.js:
--------------------------------------------------------------------------------
1 | export const d = "d";
2 | export const e = "e";
3 | export const f = "f";
4 | export default "default";
5 | 


--------------------------------------------------------------------------------
/test/export/default-expression.js:
--------------------------------------------------------------------------------
1 | let count = 0;
2 | 
3 | // This default expression will evaluate to 0 if the parentheses are
4 | // mistakenly stripped away.
5 | export default (count++, count);
6 | 


--------------------------------------------------------------------------------
/test/export/default-function.js:
--------------------------------------------------------------------------------
 1 | import { strictEqual } from "assert";
 2 | 
 3 | const obj = {};
 4 | 
 5 | export default function f() {
 6 |   return obj;
 7 | }
 8 | 
 9 | export function check(g) {
10 |   strictEqual(f, g);
11 |   strictEqual(f(), obj);
12 |   strictEqual(g(), obj);
13 | }
14 | 


--------------------------------------------------------------------------------
/test/export/default/anon-class.js:
--------------------------------------------------------------------------------
1 | export default class {
2 |   constructor(value) {
3 |     this.value = value;
4 |   }
5 | };
6 | 


--------------------------------------------------------------------------------
/test/export/default/anon-function.js:
--------------------------------------------------------------------------------
1 | export default function (value) {
2 |   return value + 1;
3 | };
4 | 


--------------------------------------------------------------------------------
/test/export/default/array.js:
--------------------------------------------------------------------------------
1 | export default [1, 2, 3];
2 | 


--------------------------------------------------------------------------------
/test/export/default/from.js:
--------------------------------------------------------------------------------
1 | export { default } from "./object";
2 | 


--------------------------------------------------------------------------------
/test/export/default/function.js:
--------------------------------------------------------------------------------
1 | export default function f() {
2 |   return f;
3 | };
4 | 


--------------------------------------------------------------------------------
/test/export/default/identifier.js:
--------------------------------------------------------------------------------
1 | const foo = 42;
2 | export default foo;
3 | 


--------------------------------------------------------------------------------
/test/export/default/named-class.js:
--------------------------------------------------------------------------------
1 | export default class A {
2 |   constructor(a, b) {
3 |     this.sum = a + b;
4 |   }
5 | };
6 | 


--------------------------------------------------------------------------------
/test/export/default/number.js:
--------------------------------------------------------------------------------
1 | export default 42;
2 | 


--------------------------------------------------------------------------------
/test/export/default/object.js:
--------------------------------------------------------------------------------
1 | export default {
2 |   foo: 42
3 | };
4 | 


--------------------------------------------------------------------------------
/test/export/destructuring.js:
--------------------------------------------------------------------------------
1 | export const { a, b: c, c: d = 1234 } = {
2 |   a: "a",
3 |   b: "b"
4 | };
5 | 
6 | export const [x, y, ...rest] = [1, 2, a, c, d];
7 | 


--------------------------------------------------------------------------------
/test/export/extensions.js:
--------------------------------------------------------------------------------
1 | export * as ns1 from "../misc/abc";
2 | export { a, b as c }, * as ns2 from "../misc/abc";
3 | export def1 from "../misc/abc";
4 | export def2, { b, c as d } from "../misc/abc";
5 | export def3, * as ns3 from "../misc/abc";
6 | export * as ns4, { c as e }, def4 from "../misc/abc";
7 | 


--------------------------------------------------------------------------------
/test/export/from-ordering-a.js:
--------------------------------------------------------------------------------
1 | export const aName = module.id.split("/").pop();
2 | import { report } from "./from-ordering-common.js";
3 | report(aName);
4 | 


--------------------------------------------------------------------------------
/test/export/from-ordering-b.js:
--------------------------------------------------------------------------------
1 | export const bName = module.id.split("/").pop();
2 | import { report } from "./from-ordering-common.js";
3 | report(bName);
4 | 


--------------------------------------------------------------------------------
/test/export/from-ordering-c.js:
--------------------------------------------------------------------------------
1 | export const cName = module.id.split("/").pop();
2 | import { report } from "./from-ordering-common.js";
3 | report(cName);
4 | 


--------------------------------------------------------------------------------
/test/export/from-ordering-common.js:
--------------------------------------------------------------------------------
1 | export const names = [];
2 | export function report(name) {
3 |   names.push(name);
4 | }
5 | 


--------------------------------------------------------------------------------
/test/export/from-ordering.js:
--------------------------------------------------------------------------------
1 | import { aName} from "./from-ordering-a.js";
2 | export { aName };
3 | export * from "./from-ordering-b.js";
4 | export { cName } from "./from-ordering-c.js";
5 | 


--------------------------------------------------------------------------------
/test/export/from.js:
--------------------------------------------------------------------------------
1 | export {a} from "../misc/abc";
2 | export {b, c} from "../misc/abc";
3 | export {a as ay} from "../misc/abc";
4 | export {a as default, b as bee} from "../misc/abc";
5 | export {default as foo} from "../misc/abc";
6 | 


--------------------------------------------------------------------------------
/test/export/later.js:
--------------------------------------------------------------------------------
 1 | import { strictEqual } from "assert";
 2 | 
 3 | export default "default-1";
 4 | export let val = "value-1";
 5 | 
 6 | export function exportAgain() {
 7 |   // Neither of these re-export styles should work, because the original
 8 |   // export default still takes precedence over anything else.
 9 |   module.exportDefault(exports.default = "default-2");
10 | 
11 |   // This style also does not work, because the getter function for the
12 |   // variable val is all that matters.
13 |   exports.val = "ignored";
14 | 
15 |   val = +(val.split("-")[1]);
16 |   val = "value-" + ++val;
17 | }
18 | 
19 | export function oneLastExport() {
20 |   strictEqual(
21 |     val = "value-3",
22 |     "value-3"
23 |   );
24 | }
25 | 


--------------------------------------------------------------------------------
/test/export/names.js:
--------------------------------------------------------------------------------
 1 | const foo = "foo";
 2 | const bar = "bar";
 3 | const baz = "baz";
 4 | 
 5 | export {foo};
 6 | export {bar, baz};
 7 | export {foo as foo2};
 8 | export {foo as foo3, baz as baz2};
 9 | export {foo as default};
10 | 


--------------------------------------------------------------------------------
/test/export/nested.js:
--------------------------------------------------------------------------------
 1 | export function outer() {
 2 |   import { a as ay } from "../misc/abc";
 3 |   import { b as bee } from "../misc/abc";
 4 |   import { c as see } from "../misc/abc";
 5 |   return [
 6 |     ay,
 7 |     bee,
 8 |     see
 9 |   ];
10 | }
11 | 


--------------------------------------------------------------------------------
/test/export/renamed.js:
--------------------------------------------------------------------------------
1 | let a = "a";
2 | 
3 | export function append(suffix) {
4 |   return a += suffix;
5 | }
6 | 
7 | export { a as x, a as y };
8 | 


--------------------------------------------------------------------------------
/test/export/sealed.js:
--------------------------------------------------------------------------------
1 | exports.name = module.id;
2 | 
3 | exports.setName = function (newName) {
4 |   module.runSetters(exports.name = newName);
5 | };
6 | 
7 | Object.seal(exports);
8 | 
9 | 


--------------------------------------------------------------------------------
/test/export/shadowed.js:
--------------------------------------------------------------------------------
1 | export const constructor = "a";
2 | export const hasOwnProperty = "b";
3 | export const toString = "c";
4 | export const valueOf = "d";
5 | 


--------------------------------------------------------------------------------
/test/export/some.js:
--------------------------------------------------------------------------------
 1 | export { a, b as v } from "../misc/abc";
 2 | 
 3 | import { c as cee } from "../misc/abc.js";
 4 | 
 5 | export { cee as si, c };
 6 | 
 7 | function c() {
 8 |   return "c";
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/export/swap-later.js:
--------------------------------------------------------------------------------
1 | export let { x, y } = { x: 1, y: 2 };
2 | export function swap() {
3 |   [x, y] = [y, x];
4 | };
5 | 


--------------------------------------------------------------------------------
/test/file-extension-tests.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | import { join } from "path";
 3 | import {
 4 |   readFileSync,
 5 |   writeFileSync
 6 | } from "fs";
 7 | 
 8 | const fixturePath = join(__dirname, "file-extension");
 9 | const content = readFileSync(join(fixturePath, "a.mjs"));
10 | 
11 | describe("file extension", () => {
12 |   function check(modulePath) {
13 |     let exported;
14 | 
15 |     try {
16 |       exported = require(modulePath).default;
17 |     } catch (e) {}
18 | 
19 |     assert.strictEqual(exported, "a");
20 |   }
21 | 
22 |   [".mjs"].forEach((ext) => {
23 |     it(`compiles ${ext} files`, () => {
24 |       check(join(fixturePath, "a" + ext));
25 |     });
26 |   });
27 | });
28 | 


--------------------------------------------------------------------------------
/test/file-extension/a.mjs:
--------------------------------------------------------------------------------
1 | export { a as default } from "../misc/abc.js";
2 | 


--------------------------------------------------------------------------------
/test/hoisting-tests.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | 
 3 | describe("hoisted function declarations", () => {
 4 |   it("should be accessible before evaluation finishes", () => {
 5 |     import { a } from "./hoisting/a.js";
 6 |     import { b } from "./hoisting/b.js";
 7 |     assert.strictEqual(a(), b);
 8 |     assert.strictEqual(b(), a);
 9 |   });
10 | });
11 | 


--------------------------------------------------------------------------------
/test/hoisting/a.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | import { b } from "./b.js";
 3 | 
 4 | assert.strictEqual(a(), b);
 5 | assert.strictEqual(typeof b, "function");
 6 | assert.strictEqual(b(), a);
 7 | 
 8 | export function a() {
 9 |   return b;
10 | }
11 | 


--------------------------------------------------------------------------------
/test/hoisting/b.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | import { a } from "./a.js";
 3 | 
 4 | assert.strictEqual(b(), a);
 5 | assert.strictEqual(typeof a, "function");
 6 | assert.strictEqual(a(), b);
 7 | 
 8 | export function b() {
 9 |   return a;
10 | }
11 | 


--------------------------------------------------------------------------------
/test/import-tests.js:
--------------------------------------------------------------------------------
  1 | import assert from "assert";
  2 | 
  3 | const canUseImportExtensions = process.env.REIFY_PARSER !== "babel";
  4 | 
  5 | describe("import declarations", () => {
  6 |   it("should work in nested scopes", () => {
  7 |     import { name, id } from "./import/name";
  8 |     assert.strictEqual(name, "name.js");
  9 |     assert.strictEqual(id.split("/").pop(), "name.js");
 10 |   });
 11 | 
 12 |   it("should cope with dependency cycles", () => {
 13 |     import { check as aCheck } from "./import/cycle-a";
 14 |     aCheck();
 15 | 
 16 |     import { check as bCheck } from "./import/cycle-a";
 17 |     bCheck();
 18 |   });
 19 | 
 20 |   it("should support combinations of import styles", () => {
 21 |     import * as abc1 from "./misc/abc";
 22 |     import abc2, * as abc3 from "./misc/abc";
 23 |     import { default as abc4 } from "./misc/abc";
 24 |     import abc5, { a as ay, b as bee, c } from "./misc/abc";
 25 | 
 26 |     function check(ns) {
 27 |       assert.strictEqual(ns.a, "a");
 28 |       assert.strictEqual(ns.b, "b");
 29 |       assert.strictEqual(ns.c, "c");
 30 |     }
 31 | 
 32 |     check(abc1);
 33 |     check(abc2);
 34 |     check(abc3);
 35 |     check(abc4);
 36 |     check(abc5);
 37 |   });
 38 | 
 39 |   it("should import module.exports as default, by default", () => {
 40 |     import def from "./export/common.js";
 41 |     assert.strictEqual(def, "pure CommonJS");
 42 |   });
 43 | 
 44 |   it("should allow same symbol as different locals", () => {
 45 |     import { a as x, a as y } from "./misc/abc";
 46 |     assert.strictEqual(x, "a");
 47 |     assert.strictEqual(y, "a");
 48 |   });
 49 | 
 50 |   it("should support braceless-if nested imports", () => {
 51 |     for (let i = 0; i < 3; ++i) {
 52 |       if (i === 0) import { a as xa } from "./misc/abc";
 53 |       else if (i === 1) import { b as xb } from "./misc/abc";
 54 |       else import { c as xc } from "./misc/abc";
 55 |       if (i === 0) assert.strictEqual(xa, "a");
 56 |       if (i === 1) assert.strictEqual(xb, "b");
 57 |       if (i === 2) assert.strictEqual(xc, "c");
 58 |     }
 59 |   });
 60 | 
 61 |   it("should support braceless-while nested imports", () => {
 62 |     var i = 0;
 63 |     while (i++ === 0) import { a as x } from "./misc/abc";
 64 |     assert.strictEqual(x, "a");
 65 |   });
 66 | 
 67 |   it("should support braceless-do-while nested imports", () => {
 68 |     do import { b as x } from "./misc/abc";
 69 |     while (false);
 70 |     assert.strictEqual(x, "b");
 71 |   });
 72 | 
 73 |   it("should support braceless-for-in nested imports", () => {
 74 |     for (var key in { a: 123 })
 75 |       import { c as x } from "./misc/abc";
 76 |     assert.strictEqual(x, "c");
 77 |   });
 78 | 
 79 |   it("should allow CommonJS modules to set module.exports", () => {
 80 |     import f from "./cjs/module-exports-function.js";
 81 |     assert.strictEqual(typeof f, "function");
 82 |     assert.strictEqual(f(), "ok");
 83 | 
 84 |     import * as fns from "./cjs/module-exports-function.js";
 85 |     assert.strictEqual(fns.default, f);
 86 | 
 87 |     import n from "./cjs/module-exports-null.js";
 88 |     assert.strictEqual(n, null);
 89 | 
 90 |     import * as nns from "./cjs/module-exports-null.js";
 91 |     assert.strictEqual(nns.default, n);
 92 | 
 93 |     import o, { a, b, c } from "./cjs/module-exports-object.js";
 94 |     assert.deepEqual(o, { a: 1, b: 2, c: 3 });
 95 |     assert.strictEqual(a, o.a);
 96 |     assert.strictEqual(b, o.b);
 97 |     assert.strictEqual(c, o.c);
 98 |     o.c = 4;
 99 |     module.runSetters.call({
100 |       id: require.resolve("./cjs/module-exports-object.js"),
101 |       exports: o
102 |     });
103 |     assert.strictEqual(c, 4);
104 | 
105 |     import { value, reset, add } from "./cjs/bridge.js";
106 |     assert.strictEqual(value, 0);
107 |     add(10);
108 |     assert.strictEqual(value, 10);
109 |     assert.strictEqual(reset(), 0);
110 |     assert.strictEqual(value, 0);
111 | 
112 |     import * as ns1 from "./cjs/module-exports-esModule.js";
113 |     import * as ns2 from "./cjs/module-exports-esModule.js";
114 |     assert.strictEqual(typeof ns1, "object");
115 |     assert.strictEqual(ns1, ns2);
116 | 
117 |     import def from "./cjs/export-default-property.js";
118 |     import * as defNs from "./cjs/export-default-property.js";
119 |     assert.strictEqual(def.default, "oyez");
120 |     assert.strictEqual(def, defNs.default);
121 |   });
122 | 
123 |   (canUseImportExtensions ? it : xit)(
124 |   "should support import extensions", () => {
125 |     import {
126 |       def1, def2, def3, def4,
127 |       ns1, ns2, ns3, ns4,
128 |       a, b, c, d, e
129 |     } from "./import/extensions";
130 | 
131 |     import def, {
132 |       a as _a,
133 |       b as _b,
134 |       b as _c,
135 |       c as _d,
136 |       c as _e,
137 |     } from "./misc/abc";
138 | 
139 |     assert.strictEqual(def, def1);
140 |     assert.strictEqual(def, def2);
141 |     assert.strictEqual(def, def3);
142 |     assert.strictEqual(def, def4);
143 | 
144 |     function checkNS(ns) {
145 |       assert.strictEqual(ns.a, def.a);
146 |       assert.strictEqual(ns.b, def.b);
147 |       assert.strictEqual(ns.c, def.c);
148 |       assert.notStrictEqual(ns, def);
149 |     }
150 | 
151 |     checkNS(ns1);
152 |     checkNS(ns2);
153 |     checkNS(ns3);
154 |     checkNS(ns4);
155 | 
156 |     assert.strictEqual(a, _a);
157 |     assert.strictEqual(b, _b);
158 |     assert.strictEqual(c, _c);
159 |     assert.strictEqual(d, _d);
160 |     assert.strictEqual(e, _e);
161 |   });
162 | });
163 | 


--------------------------------------------------------------------------------
/test/import/cycle-a.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | 
 3 | export const one = 1;
 4 | 
 5 | import {
 6 |   one as bOne,
 7 |   two as bTwo,
 8 | } from "./cycle-b";
 9 | 
10 | export const two = 2;
11 | 
12 | export function check() {
13 |   assert.strictEqual(bOne, 1);
14 |   assert.strictEqual(bTwo, 2);
15 | }
16 | 


--------------------------------------------------------------------------------
/test/import/cycle-b.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | 
 3 | export const one = 1;
 4 | 
 5 | import {
 6 |   one as aOne,
 7 |   two as aTwo,
 8 | } from "./cycle-a";
 9 | 
10 | export const two = 2;
11 | 
12 | export function check() {
13 |   assert.strictEqual(aOne, 1);
14 |   assert.strictEqual(aTwo, 2);
15 | }
16 | 


--------------------------------------------------------------------------------
/test/import/extensions.js:
--------------------------------------------------------------------------------
 1 | import * as ns1 from "../misc/abc";
 2 | import { a, b as c }, * as ns2 from "../misc/abc";
 3 | import def1 from "../misc/abc";
 4 | import def2, { b, c as d } from "../misc/abc";
 5 | import def3, * as ns3 from "../misc/abc";
 6 | import * as ns4, { c as e }, def4 from "../misc/abc";
 7 | 
 8 | export {
 9 |   def1, def2, def3, def4,
10 |   ns1, ns2, ns3, ns4,
11 |   a, b, c, d, e
12 | };
13 | 


--------------------------------------------------------------------------------
/test/import/name.js:
--------------------------------------------------------------------------------
1 | const path = require("path");
2 | 
3 | export const id = module.id,
4 |   name = path.basename(__filename);
5 | 
6 | export function foo() {
7 |   return "foo";
8 | }
9 | 


--------------------------------------------------------------------------------
/test/misc-tests.js:
--------------------------------------------------------------------------------
 1 | const assert = require("assert");
 2 | 
 3 | describe("spec compliance", () => {
 4 |   it("should establish live binding of values", () => {
 5 |     import { value, reset, add } from "./misc/live";
 6 |     reset();
 7 |     assert.equal(value, 0);
 8 |     add(2);
 9 |     assert.equal(value, 2);
10 |   });
11 | 
12 |   it("should execute modules in the correct order", () => {
13 |     import { getLog } from "./misc/order-tracker";
14 |     import "./misc/order-c";
15 |     assert.deepEqual(getLog(), ["a", "b", "c"]);
16 |   });
17 | 
18 |   it("should bind exports before the module executes", () => {
19 |     import value from "./export/cycle-a";
20 |     assert.equal(value, true);
21 |   });
22 | 
23 |   it("should not export the default binding of namespace exports", () => {
24 |     import * as ns from "./misc/export-all.js";
25 |     ns.checkNoDefault();
26 |   });
27 | 
28 |   it('... unless "*+" or module.makeNsSetter(true) is used', () => {
29 |     import eff, * as ns from "./misc/export-all-with-default.js";
30 |     assert.strictEqual(eff(), "eff");
31 |     assert.strictEqual(ns.default, eff);
32 |   });
33 | });
34 | 
35 | describe("built-in modules", () => {
36 |   it("should fire setters if already loaded", () => {
37 |     // The "module" module is required in ../lib/node.js before we begin
38 |     // compiling anything.
39 |     import { Module as M } from "module";
40 |     assert.ok(module instanceof M);
41 |   });
42 | });
43 | 
44 | describe("sealed module.exports objects", () => {
45 |   it("should not pose any problems", () => {
46 |     import { name, setName } from "./export/sealed.js";
47 |     import { relative } from "path";
48 | 
49 |     assert.strictEqual(
50 |       relative(__dirname, name),
51 |       "export/sealed.js"
52 |     );
53 | 
54 |     setName("oyez");
55 |     assert.strictEqual(name, "oyez");
56 |   });
57 | });
58 | 
59 | describe("exceptional imports", () => {
60 |   it("should not be triggered if unnamed", () => {
61 |     import { safe } from "./misc/risky-exports.js";
62 |     assert.strictEqual(safe, "safe");
63 | 
64 |     import risky from "./misc/risky-exports.js";
65 |     assert.deepEqual(
66 |       Object.keys(risky).sort(),
67 |       ["safe", "unsafe"]
68 |     );
69 | 
70 |     try {
71 |       import * as ns from "./misc/risky-exports.js";
72 | 
73 |       assert.deepEqual(
74 |         Object.keys(ns).sort(),
75 |         ["default", "safe", "unsafe"]
76 |       );
77 | 
78 |       // This assertion would fail if its arguments could be evaluated,
79 |       // but the ns.unsafe expression throws first.
80 |       assert.strictEqual(ns.unsafe, "moot");
81 | 
82 |     } catch (e) {
83 |       assert.strictEqual(e.message, "unsafe");
84 |     }
85 |   });
86 | });
87 | 
88 | describe("object-like module.exports", () => {
89 |   it("should expose their properties via `export * from ...`", () => {
90 |     import { union, forEach } from "./export/all-lodash.js";
91 |     assert.strictEqual(typeof union, "function");
92 |     assert.strictEqual(typeof forEach, "function");
93 |   });
94 | });
95 | 


--------------------------------------------------------------------------------
/test/misc/abc.js:
--------------------------------------------------------------------------------
1 | exports.a = "a";
2 | exports.b = "b";
3 | exports.c = "c";
4 | 


--------------------------------------------------------------------------------
/test/misc/export-all-with-default.js:
--------------------------------------------------------------------------------
1 | module.link("./export-default.js", {
2 |   // The compiler never generates `export * from ...` code that includes
3 |   // the "default" property (per spec), but hand-written code can use "*+"
4 |   // or module.makeNsSetter(true) to include the "default" property.
5 |   "*": "*+"
6 | });
7 | 


--------------------------------------------------------------------------------
/test/misc/export-all.js:
--------------------------------------------------------------------------------
1 | import assert from "assert"
2 | import * as ns from "../export/all-multiple.js"
3 | 
4 | export function checkNoDefault() {
5 |   assert.ok(! ("default" in ns))
6 | }
7 | 


--------------------------------------------------------------------------------
/test/misc/export-default.js:
--------------------------------------------------------------------------------
1 | export default function f() {
2 |   return "eff";
3 | }
4 | 


--------------------------------------------------------------------------------
/test/misc/live.js:
--------------------------------------------------------------------------------
 1 | export var value = reset();
 2 | 
 3 | export function add(n) {
 4 |   value += n;
 5 | };
 6 | 
 7 | export function reset() {
 8 |   return value = 0;
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/misc/order-a.js:
--------------------------------------------------------------------------------
1 | import { log } from "./order-tracker";
2 | log("a");
3 | 


--------------------------------------------------------------------------------
/test/misc/order-b.js:
--------------------------------------------------------------------------------
1 | import { log } from "./order-tracker";
2 | log("b");
3 | 


--------------------------------------------------------------------------------
/test/misc/order-c.js:
--------------------------------------------------------------------------------
1 | import { log } from "./order-tracker";
2 | import "./order-a";
3 | log("c");
4 | import "./order-b";
5 | 


--------------------------------------------------------------------------------
/test/misc/order-tracker.js:
--------------------------------------------------------------------------------
1 | const data = [];
2 | export function log(x) {
3 |   data.push(x);
4 | };
5 | export function getLog() {
6 |   return data;
7 | };
8 | 


--------------------------------------------------------------------------------
/test/misc/risky-exports.js:
--------------------------------------------------------------------------------
 1 | Object.defineProperties(exports, {
 2 |   safe: {
 3 |     enumerable: true,
 4 |     value: "safe"
 5 |   },
 6 | 
 7 |   unsafe: {
 8 |     enumerable: true,
 9 |     get() {
10 |       throw new Error("unsafe");
11 |     }
12 |   }
13 | });
14 | 


--------------------------------------------------------------------------------
/test/node_modules/disabled/index.js:
--------------------------------------------------------------------------------
1 | function get() {
2 |   import assert from "assert";
3 |   return assert;
4 | }
5 | 
6 | export default get();
7 | 


--------------------------------------------------------------------------------
/test/node_modules/enabled/enabled.js:
--------------------------------------------------------------------------------
1 | import assert from "assert";
2 | export default assert;
3 | 


--------------------------------------------------------------------------------
/test/node_modules/enabled/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "enabled",
3 |   "main": "enabled.js",
4 |   "dependencies": {
5 |     "reify": "*"
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/test/output-tests.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | import { compile } from "../lib/compiler.js";
 3 | import { files } from "./all-files.js";
 4 | import {
 5 |   basename,
 6 |   relative,
 7 |   sep,
 8 | } from "path";
 9 | 
10 | const filesToTest = Object.create(null);
11 | 
12 | Object.keys(files).forEach((absPath) => {
13 |   const code = files[absPath];
14 |   const relPath = relative(__dirname, absPath);
15 |   const relParts = relPath.split(sep);
16 | 
17 |   if (relParts[0]  === "output") {
18 |     const testName = relParts[1];
19 |     const testType = basename(relParts[2], ".js");
20 | 
21 |     if (! filesToTest[testName]) {
22 |       filesToTest[testName] = Object.create(null);
23 |     }
24 |     filesToTest[testName][testType] = code;
25 |   }
26 | });
27 | 
28 | describe("output", () => {
29 |   function check(data) {
30 |     const code = compile(data.actual, {
31 |       parse: require("../lib/parsers/acorn.js").parse
32 |     }).code;
33 | 
34 |     // Consolidate semicolons, then trim blank lines and trailing whitespace.
35 |     const actual = code.replace(/;{2,}/g, ";").replace(/^ +$/gm, "").trimRight();
36 |     const expected = data.expected.trimRight();
37 | 
38 |     assert.strictEqual(actual, expected);
39 |   }
40 | 
41 |   Object.keys(filesToTest).forEach((key) => {
42 |     const data = filesToTest[key];
43 |     const testName = key.split("-").join(" ");
44 | 
45 |     it("compiles " + testName + " example as expected", () => {
46 |       check(data);
47 |     });
48 |   });
49 | });
50 | 


--------------------------------------------------------------------------------
/test/output/anon-class/actual.js:
--------------------------------------------------------------------------------
1 | export default class {
2 |   constructor(value) {
3 |     this.value = value;
4 |   }
5 | };
6 | 


--------------------------------------------------------------------------------
/test/output/anon-class/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";module.exportDefault(class {
2 |   constructor(value) {
3 |     this.value = value;
4 |   }
5 | });
6 | 


--------------------------------------------------------------------------------
/test/output/declarations-basic/actual.js:
--------------------------------------------------------------------------------
 1 | export const a = 1;
 2 | export const b = function () {
 3 |   return d;
 4 | };
 5 | export let c; // lazy initialization
 6 | export function d() {
 7 |   return b;
 8 | };
 9 | 
10 | c = "c";
11 | 


--------------------------------------------------------------------------------
/test/output/declarations-basic/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({c:()=>c,d:()=>d});module.export({a:()=>a,b:()=>b},true);const a = 1;
 2 | const b = function () {
 3 |   return d;
 4 | };
 5 | let c; // lazy initialization
 6 | function d() {
 7 |   return b;
 8 | };
 9 | 
10 | module.runSetters(c = "c");
11 | 


--------------------------------------------------------------------------------
/test/output/default-expression/actual.js:
--------------------------------------------------------------------------------
1 | let count = 0;
2 | 
3 | // This default expression will evaluate to 0 if the parentheses are
4 | // mistakenly stripped away.
5 | export default (count++, count);
6 | 


--------------------------------------------------------------------------------
/test/output/default-expression/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";let count = 0;
2 | 
3 | // This default expression will evaluate to 0 if the parentheses are
4 | // mistakenly stripped away.
5 | module.exportDefault((count++, count));
6 | 


--------------------------------------------------------------------------------
/test/output/default-function/actual.js:
--------------------------------------------------------------------------------
 1 | import { strictEqual } from "assert";
 2 | 
 3 | const obj = {};
 4 | 
 5 | export default function f() {
 6 |   return obj;
 7 | }
 8 | 
 9 | export function check(g) {
10 |   strictEqual(f, g);
11 |   strictEqual(f(), obj);
12 |   strictEqual(g(), obj);
13 | }
14 | 


--------------------------------------------------------------------------------
/test/output/default-function/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({default:()=>f,check:()=>check});var strictEqual;module.link("assert",{strictEqual(v){strictEqual=v}},0);
 2 | 
 3 | const obj = {};
 4 | 
 5 | function f() {
 6 |   return obj;
 7 | }
 8 | 
 9 | function check(g) {
10 |   strictEqual(f, g);
11 |   strictEqual(f(), obj);
12 |   strictEqual(g(), obj);
13 | }
14 | 


--------------------------------------------------------------------------------
/test/output/eval/actual.js:
--------------------------------------------------------------------------------
1 | let localValue = "original";
2 | export { localValue as value };
3 | export function run(code) {
4 |   return eval(code);
5 | };
6 | 


--------------------------------------------------------------------------------
/test/output/eval/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";module.export({value:()=>localValue,run:()=>run});let localValue = "original";
2 | 
3 | function run(code) {
4 |   return module.runSetters(eval(code));
5 | };
6 | 


--------------------------------------------------------------------------------
/test/output/export-all-multiple/actual.js:
--------------------------------------------------------------------------------
1 | import * as n from "./abc";
2 | export * from "./def";
3 | export { n as Abc };
4 | 


--------------------------------------------------------------------------------
/test/output/export-all-multiple/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";module.export({Abc:()=>n});var n;module.link("./abc",{"*"(v){n=v}},0);module.link("./def",{"*":"*"},1);
2 | 


--------------------------------------------------------------------------------
/test/output/export-all/actual.js:
--------------------------------------------------------------------------------
1 | export * from "./abc";
2 | export default "default";
3 | 


--------------------------------------------------------------------------------
/test/output/export-all/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";module.link("./abc",{"*":"*"},0);
2 | module.exportDefault("default");
3 | 


--------------------------------------------------------------------------------
/test/output/export-multi-namespace/actual.js:
--------------------------------------------------------------------------------
1 | export * as a, * as b from "module";
2 | 


--------------------------------------------------------------------------------
/test/output/export-multi-namespace/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";module.link("module",{"*":["a","b"]},0);
2 | 


--------------------------------------------------------------------------------
/test/output/export-some/actual.js:
--------------------------------------------------------------------------------
 1 | export { a, b as v } from "./abc";
 2 | 
 3 | import { c as cee } from "./abc.js";
 4 | 
 5 | export { cee as si, c };
 6 | 
 7 | function c() {
 8 |   return "c";
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/output/export-some/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({si:()=>cee,c:()=>c});module.link("./abc",{a:"a",b:"v"},0);var cee;module.link("./abc.js",{c(v){cee=v}},1);
 2 | 
 3 | 
 4 | 
 5 | 
 6 | 
 7 | function c() {
 8 |   return "c";
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/output/lines/actual.js:
--------------------------------------------------------------------------------
 1 | import {
 2 |   strictEqual,
 3 |   // blank line
 4 |   deepEqual,
 5 | }
 6 | from "assert";
 7 | 
 8 | export
 9 | default
10 | 
11 | function check()
12 | 
13 | {
14 |   const error = new Error; // Line 14
15 |   const line = +error.stack.split("\n")[1].split(":")[1];
16 |   strictEqual(line, 14);
17 | }
18 | 


--------------------------------------------------------------------------------
/test/output/lines/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({default:()=>check});var strictEqual,deepEqual;module.link("assert",{strictEqual(v){strictEqual=v},deepEqual(v){deepEqual=v}},0);
 2 | 
 3 | 
 4 | 
 5 | 
 6 | 
 7 | 
 8 | 
 9 | 
10 | 
11 | function check()
12 | 
13 | {
14 |   const error = new Error; // Line 14
15 |   const line = +error.stack.split("\n")[1].split(":")[1];
16 |   strictEqual(line, 14);
17 | }
18 | 


--------------------------------------------------------------------------------
/test/output/live/actual.js:
--------------------------------------------------------------------------------
 1 | export var value = reset();
 2 | 
 3 | export function reset() {
 4 |   return value = 0;
 5 | }
 6 | 
 7 | export function add(x) {
 8 |   value += x;
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/output/live/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({value:()=>value,reset:()=>reset,add:()=>add});var value = reset();
 2 | 
 3 | function reset() {
 4 |   return module.runSetters(value = 0);
 5 | }
 6 | 
 7 | function add(x) {
 8 |   module.runSetters(value += x);
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/output/mixed-keys/actual.js:
--------------------------------------------------------------------------------
1 | import { _1, $1 } from "./a";
2 | import _2, * as $2 from "./a";
3 | 


--------------------------------------------------------------------------------
/test/output/mixed-keys/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";var _1,$1;module.link("./a",{_1(v){_1=v},$1(v){$1=v}},0);var _2,$2;module.link("./a",{default(v){_2=v},"*"(v){$2=v}},1);
2 | 


--------------------------------------------------------------------------------
/test/output/name/actual.js:
--------------------------------------------------------------------------------
1 | const path = require("path");
2 | 
3 | export const id = module.id,
4 |   name = path.basename(__filename);
5 | 
6 | export function foo() {
7 |   return "foo";
8 | }
9 | 


--------------------------------------------------------------------------------
/test/output/name/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";module.export({foo:()=>foo});module.export({id:()=>id,name:()=>name},true);const path = require("path");
2 | 
3 | const id = module.id,
4 |   name = path.basename(__filename);
5 | 
6 | function foo() {
7 |   return "foo";
8 | }
9 | 


--------------------------------------------------------------------------------
/test/output/nested/actual.js:
--------------------------------------------------------------------------------
 1 | export function outer() {
 2 |   import { a as ay } from "./abc";
 3 |   import { b as bee } from "./abc";
 4 |   import { c as see } from "./abc";
 5 |   return [
 6 |     ay,
 7 |     bee,
 8 |     see
 9 |   ];
10 | }
11 | 


--------------------------------------------------------------------------------
/test/output/nested/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({outer:()=>outer});function outer() {var ay;module.link("./abc",{a(v){ay=v}},0);var bee;module.link("./abc",{b(v){bee=v}},1);var see;module.link("./abc",{c(v){see=v}},2);
 2 | 
 3 | 
 4 | 
 5 |   return [
 6 |     ay,
 7 |     bee,
 8 |     see
 9 |   ];
10 | }
11 | 


--------------------------------------------------------------------------------
/test/output/only-nested/actual.js:
--------------------------------------------------------------------------------
1 | function f() {
2 |   import { a, b as c } from "./module";
3 | }
4 | 


--------------------------------------------------------------------------------
/test/output/only-nested/expected.js:
--------------------------------------------------------------------------------
1 | "use strict";function f() {var a,c;module.link("./module",{a(v){a=v},b(v){c=v}},0);
2 | 
3 | }
4 | 


--------------------------------------------------------------------------------
/test/output/strict/actual.js:
--------------------------------------------------------------------------------
 1 | export function check() {
 2 |   "use strict"
 3 | 
 4 |   import { strictEqual } from "assert"
 5 |   import { a, b, c } from "../misc/abc"
 6 | 
 7 |   strictEqual(a, "a")
 8 |   strictEqual(b, "b")
 9 |   strictEqual(c, "c")
10 | 
11 |   // Returns true only if the current function is strict.
12 |   return function () {
13 |     return ! this
14 |   }()
15 | }
16 | 


--------------------------------------------------------------------------------
/test/output/strict/expected.js:
--------------------------------------------------------------------------------
 1 | "use strict";module.export({check:()=>check});function check() {
 2 |   "use strict";var strictEqual;module.link("assert",{strictEqual(v){strictEqual=v}},0);var a,b,c;module.link("../misc/abc",{a(v){a=v},b(v){b=v},c(v){c=v}},1);
 3 | 
 4 | 
 5 | 
 6 | 
 7 |   strictEqual(a, "a")
 8 |   strictEqual(b, "b")
 9 |   strictEqual(c, "c")
10 | 
11 |   // Returns true only if the current function is strict.
12 |   return function () {
13 |     return ! this
14 |   }()
15 | }
16 | 


--------------------------------------------------------------------------------
/test/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "reify-test-package",
 3 |   "private": true,
 4 |   "reify": {
 5 |     "cache-directory": ".cache/path/for/tests"
 6 |   },
 7 |   "dependencies": {
 8 |     "reify": "*"
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/test/repl-tests.js:
--------------------------------------------------------------------------------
 1 | const assert = require("assert");
 2 | const nodeMajorVersion = parseInt(process.versions.node, 10);
 3 | 
 4 | // Masquerade as the REPL module.
 5 | module.filename = null;
 6 | module.id = "<repl>";
 7 | module.loaded = false;
 8 | module.parent = void 0;
 9 | 
10 | delete require.cache[require.resolve("../node/repl-hook.js")];
11 | 
12 | describe("Node REPL", () => {
13 |   import "../node/repl-hook.js";
14 |   import { createContext } from "vm";
15 |   import { enable } from "../lib/runtime";
16 |   import repl from "repl";
17 | 
18 |   let pendingTestCount = 2;
19 | 
20 |   function finish(repl, done) {
21 |     if (typeof repl.close === "function") {
22 |       repl.close();
23 |     }
24 | 
25 |     pendingTestCount = Math.max(pendingTestCount - 1, 0);
26 |     if (pendingTestCount === 0 &&
27 |         nodeMajorVersion <= 4) {
28 |       process.stdin.end();
29 |     }
30 | 
31 |     done();
32 |   }
33 | 
34 |   it("should work with global context", (done) => {
35 |     const r = repl.start({ useGlobal: true });
36 |     enable(r.context.module);
37 | 
38 |     assert.strictEqual(typeof assertStrictEqual, "undefined");
39 | 
40 |     r.eval(
41 |       'import { strictEqual as assertStrictEqual } from "assert"',
42 |       null, // Context
43 |       "repl", // Filename
44 |       (err, result) => {
45 |         // Use the globally defined assertStrictEqual to test itself!
46 |         assertStrictEqual(typeof assertStrictEqual, "function");
47 |         finish(r, done);
48 |       }
49 |     );
50 |   });
51 | 
52 |   (nodeMajorVersion === 10 ? xit : it)
53 |   ("should work with non-global context", (done) => {
54 |     const r = repl.start({ useGlobal: false });
55 |     const context = createContext({ module, require });
56 | 
57 |     r.eval(
58 |       'import { strictEqual } from "assert"',
59 |       context,
60 |       "repl", // Filename
61 |       (err, result) => {
62 |         // Use context.strictEqual to test itself!
63 |         context.strictEqual(typeof context.strictEqual, "function");
64 |         if (typeof r.close === "function") {
65 |           r.close();
66 |         }
67 |         finish(r, done);
68 |       }
69 |     );
70 |   });
71 | });
72 | 


--------------------------------------------------------------------------------
/test/run.js:
--------------------------------------------------------------------------------
1 | describe("Parsing with " + JSON.stringify(
2 |   process.env.REIFY_PARSER || "acorn"
3 | ), () => {
4 |   require("./tests.js");
5 | });
6 | 


--------------------------------------------------------------------------------
/test/run.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -e
 4 | set -u
 5 | 
 6 | cd $(dirname "$0")
 7 | TEST_DIR=$(pwd)
 8 | 
 9 | # Make Node complain about deprecations more loudly.
10 | export NODE_PENDING_DEPRECATION=1
11 | export NODE_OPTIONS="--trace-warnings"
12 | 
13 | cd "$TEST_DIR"
14 | 
15 | rm -rf .cache
16 | export REIFY_PARSER=babel
17 | 
18 | mocha \
19 |     --require "../node" \
20 |     --reporter spec \
21 |     --full-trace \
22 |     run.js
23 | 
24 | rm -rf .cache
25 | export REIFY_PARSER=acorn
26 | 
27 | mocha \
28 |     --require "../node" \
29 |     --reporter spec \
30 |     --full-trace \
31 |     run.js
32 | 
33 | # Run tests again using test/.cache.
34 | mocha \
35 |     --require "../node" \
36 |     --reporter spec \
37 |     --full-trace \
38 |     run.js
39 | 


--------------------------------------------------------------------------------
/test/setter-tests.js:
--------------------------------------------------------------------------------
  1 | const assert = require("assert");
  2 | 
  3 | describe("module.runSetters", () => {
  4 |   it("should be called after eval(...)", () => {
  5 |     import { value, run } from "./setter/eval";
  6 | 
  7 |     assert.strictEqual(value, "original");
  8 |     const result = run('localValue = "modified"');
  9 |     assert.strictEqual(value, result);
 10 |     assert.strictEqual(value, "modified");
 11 |   });
 12 | 
 13 |   it("should be called for untouched CJS modules, too", () => {
 14 |     // Import the CommonJS module first, but do not register any setters.
 15 |     import "./setter/cycle/cjs.js";
 16 |     import { getSum } from "./setter/cycle/esm.js";
 17 |     assert.strictEqual(getSum(), 3);
 18 |   });
 19 | });
 20 | 
 21 | describe("parent setters", () => {
 22 |   it("should be run when children update exports", () => {
 23 |     import { c } from "./setter/parent";
 24 |     import { increment } from "./setter/grandchild";
 25 | 
 26 |     assert.strictEqual(c, 0);
 27 |     increment();
 28 |     assert.strictEqual(c, 1);
 29 |   });
 30 | 
 31 |   it("should not be called if replaced", () => {
 32 |     import { value, reset, add } from "./misc/live.js";
 33 | 
 34 |     let firstCallCount = 0;
 35 |     let secondCallCount = 0;
 36 | 
 37 |     module.link("./misc/live.js", {
 38 |       value: (v) => {
 39 |         ++firstCallCount;
 40 |         value = "first:" + v;
 41 |       }
 42 |     }, "key");
 43 | 
 44 |     assert.strictEqual(firstCallCount, 1);
 45 |     assert.strictEqual(value, "first:0");
 46 |     add(3);
 47 |     assert.strictEqual(firstCallCount, 2);
 48 |     assert.strictEqual(value, "first:3");
 49 |     assert.strictEqual(secondCallCount, 0);
 50 | 
 51 |     module.link("./misc/live.js", {
 52 |       value: (v) => {
 53 |         ++secondCallCount;
 54 |         value = "second:" + v;
 55 |       }
 56 |     }, "key");
 57 | 
 58 |     assert.strictEqual(firstCallCount, 2);
 59 |     assert.strictEqual(secondCallCount, 1);
 60 |     assert.strictEqual(value, "second:3");
 61 |     add(4);
 62 |     assert.strictEqual(firstCallCount, 2);
 63 |     assert.strictEqual(secondCallCount, 2);
 64 |     assert.strictEqual(value, "second:7");
 65 |   });
 66 | 
 67 |   it("should only be discarded if getter did not throw", () => {
 68 |     // Manually register setters for value and set, which are marked as
 69 |     // constant in the fake-const.js module, even though they are actually
 70 |     // mutable (see below).
 71 |     let value, set;
 72 |     let valueSetterCallCount = 0;
 73 |     module.link("./setter/fake-const.js", {
 74 |       value: v => {
 75 |         value = v;
 76 |         valueSetterCallCount += 1;
 77 |       },
 78 |       set: v => set = v
 79 |     });
 80 | 
 81 |     // Because the getter for value in fake-const.js throws, the initial
 82 |     // value here is undefined, and our live binding to that value is
 83 |     // maintained for now.
 84 |     assert.strictEqual(value, void 0);
 85 |     assert.strictEqual(valueSetterCallCount, 1);
 86 | 
 87 |     // Since the exported value is marked as constant, the setter that
 88 |     // updates our copy of value should be discarded as soon as it has
 89 |     // been called with the final value, but this set(2) still works
 90 |     // because the getter threw the last time it was called. After this,
 91 |     // however, the setter function will be discarded.
 92 |     set(2);
 93 |     assert.strictEqual(value, 2);
 94 |     assert.strictEqual(valueSetterCallCount, 2);
 95 | 
 96 |     // Because the exported value is marked as constant, this set(3) is
 97 |     // not reflected in this scope, because the setter that we registered
 98 |     // above has been thrown away.
 99 |     set(3);
100 |     assert.strictEqual(value, 2);
101 |     assert.strictEqual(valueSetterCallCount, 2);
102 |   });
103 | });
104 | 


--------------------------------------------------------------------------------
/test/setter/child.js:
--------------------------------------------------------------------------------
1 | export { c } from "./grandchild";
2 | 


--------------------------------------------------------------------------------
/test/setter/cycle/cjs.js:
--------------------------------------------------------------------------------
1 | exports.one = 1;
2 | require("./esm.js");
3 | exports.two = 2;
4 | 


--------------------------------------------------------------------------------
/test/setter/cycle/esm.js:
--------------------------------------------------------------------------------
1 | import { one, two } from "./cjs.js";
2 | 
3 | export function getSum() {
4 |   return one + two;
5 | }
6 | 


--------------------------------------------------------------------------------
/test/setter/eval.js:
--------------------------------------------------------------------------------
1 | let localValue = "original";
2 | export { localValue as value };
3 | export function run(code) {
4 |   return eval(code);
5 | };
6 | 


--------------------------------------------------------------------------------
/test/setter/fake-const.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | // Throw once for the mod.runSetters() call in reify/node/compile-hook.js,
 4 | // and again for the first time we call module.runSetters in set below.
 5 | let throwTimes = 2;
 6 | let value = 1;
 7 | 
 8 | module.export({
 9 |   value: () => {
10 |     if (throwTimes-- > 0) {
11 |       throw new Error("simulated");
12 |     }
13 |     return value;
14 |   },
15 |   set: () => set
16 | }, true); // Mark as constant.
17 | 
18 | function set(to) {
19 |   return module.runSetters(value = to);
20 | }
21 | 


--------------------------------------------------------------------------------
/test/setter/grandchild.js:
--------------------------------------------------------------------------------
1 | export let c = 0;
2 | export function increment() {
3 |   ++c;
4 |   module.runSetters();
5 | };
6 | 


--------------------------------------------------------------------------------
/test/setter/parent.js:
--------------------------------------------------------------------------------
1 | import { c } from "./child";
2 | export { c };
3 | 


--------------------------------------------------------------------------------
/test/tests.js:
--------------------------------------------------------------------------------
 1 | import "./import-tests.js";
 2 | import "./export-tests.js";
 3 | import "./setter-tests.js";
 4 | import "./misc-tests.js";
 5 | import "./compiler-tests.js";
 6 | import "./output-tests.js";
 7 | import "./file-extension-tests.js";
 8 | import "./transform-tests.js";
 9 | import "./babel-plugin-tests.js";
10 | import "./repl-tests.js";
11 | import "./hoisting-tests.js";
12 | 


--------------------------------------------------------------------------------
/test/transform-tests.js:
--------------------------------------------------------------------------------
 1 | import assert from "assert";
 2 | import { relative } from "path";
 3 | import {
 4 |   compile,
 5 |   transform,
 6 |   makeUniqueId,
 7 | } from "../lib/compiler.js";
 8 | import { prettyPrint } from "recast";
 9 | import { files } from "./all-files.js";
10 | 
11 | describe("compiler.transform", () => {
12 |   function check(options) {
13 |     Object.keys(files).forEach(function (absPath) {
14 |       if (typeof options.reject === "function" &&
15 |           options.reject(relative(__dirname, absPath))) {
16 |         return;
17 |       }
18 | 
19 |       const code = files[absPath];
20 |       const ast = options.parse(code);
21 | 
22 |       options.moduleAlias = makeUniqueId("module", code);
23 | 
24 |       transform(ast, options);
25 | 
26 |       assert.strictEqual(
27 |         prettyPrint(compile(code, options).ast).code,
28 |         prettyPrint(ast).code,
29 |         "Transform mismatch for " + absPath
30 |       );
31 |     });
32 |   }
33 | 
34 |   it("gives the same results as compile with @babel/parser", () => {
35 |     check({
36 |       ast: true,
37 |       parse: require("../lib/parsers/babel.js").parse,
38 |       reject: (relPath) => {
39 |         return relPath === "export/extensions.js" ||
40 |                relPath === "import/extensions.js" ||
41 |                relPath.startsWith("output/export-multi-namespace/");
42 |       }
43 |     });
44 |   }).timeout(5000);
45 | 
46 |   it("gives the same results as compile with acorn", () => {
47 |     check({
48 |       ast: true,
49 |       parse: require("../lib/parsers/acorn.js").parse
50 |     });
51 |   }).timeout(5000);
52 | });
53 | 


--------------------------------------------------------------------------------
/test/undeclared-export.js:
--------------------------------------------------------------------------------
1 | export { Array as GlobalArray }
2 | 


--------------------------------------------------------------------------------