Initial commit

node_modules/esm-import-transformer/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+on:
+  push:
+    branches-ignore:
+      - "gh-pages"
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
+        node: ["16", "18", "20"]
+    name: Node.js ${{ matrix.node }} on ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup node
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node }}
+          # cache: npm
+      - run: npm install
+      - run: npm test
+env:
+  YARN_GPG: no

node_modules/esm-import-transformer/README.md

@@ -0,0 +1,91 @@
+# esm-import-transformer
+
+Can transform any ESM source code `import` URLs using an import maps object. This package works in ESM or CJS.
+
+```js
+// Input source code:
+import {html, css, LitElement} from "lit";
+
+// Transform with an import map:
+import {html, css, LitElement} from "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js";
+
+// Or transform to a dynamic import:
+const {html, css, LitElement} = await import("lit");
+
+// Or transform to CommonJS require:
+const {html, css, LitElement} = require("lit");
+```
+
+## Usage
+
+```js
+// ESM
+import { ImportTransformer } from "esm-import-transformer";
+
+// or CJS
+const { ImportTransformer } = await import("esm-import-transformer");
+```
+
+### Transform with an import map
+
+Pass in a source code string and an [import maps](https://github.com/WICG/import-maps) object.
+
+```js
+let sourceCode = `import {html, css, LitElement} from "lit";`;
+let it = new ImportTransformer(sourceCode);
+
+let importMap = {
+  imports: {
+    lit: "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js"
+  }
+};
+let outputCode = it.transformWithImportMap(importMap);
+// returns: `import {html, css, LitElement} from "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js";`
+```
+
+### Transform to dynamic `import()`
+
+```js
+let sourceCode = `import {html, css, LitElement} from "lit";`;
+let it = new ImportTransformer(sourceCode);
+
+let outputCode = it.transformToDynamicImport();
+// returns: `const {html, css, LitElement} = await import("lit");`
+```
+
+### Transform to `require()`
+
+_Added in v3.0.1_: This method does not require that the downstream package is CommonJS, but just know that code will fail if you try to run it on a package that is not CommonJS.
+
+```js
+let sourceCode = `import {html, css, LitElement} from "lit";`;
+let it = new ImportTransformer(sourceCode);
+
+let outputCode = it.transformToRequire();
+// returns: `const {html, css, LitElement} = require("lit");`
+```
+
+### Has imports?
+
+_Added in v3.0.2_ Returns true if the code has any top level `import`.
+
+```js
+let sourceCode = `import {html, css, LitElement} from "lit";`;
+let it = new ImportTransformer(sourceCode);
+it.hasImports(); // true
+```
+
+```js
+let sourceCode = `const {html, css, LitElement} = require("lit");`;
+let it = new ImportTransformer(sourceCode);
+it.hasImports(); // false
+```
+
+
+## Installation
+
+Available on [npm](https://www.npmjs.com/package/esm-import-transformer)
+
+```
+npm install esm-import-transformer
+```

node_modules/esm-import-transformer/import-transformer.js

@@ -0,0 +1,130 @@
+import * as acorn from "acorn";
+
+export class ImportTransformer {
+  constructor(input, ast) {
+    this.parse(input, ast);
+  }
+
+  parse(input, ast) {
+    if(!input) {
+      throw new Error("Missing input to ImportTransformer, received: " + input)
+    }
+
+    this.originalSource = input;
+
+    if(ast) {
+      this.ast = ast;
+    } else {
+      this.ast = acorn.parse(input, {
+        sourceType: "module",
+        ecmaVersion: "latest"
+      });
+    }
+  }
+
+  static transformImportSource(str, sourceNode, indexOffset = 0, importMap = {}) {
+    let { start, end, value } = sourceNode;
+    // Could be improved by https://www.npmjs.com/package/@import-maps/resolve
+    let resolved = importMap?.imports && importMap?.imports[value];
+    if(resolved) {
+      return {
+        code: str.slice(0, start + 1 + indexOffset) + resolved + str.slice(end - 1 + indexOffset),
+        offset: resolved.length - value.length,
+      };
+    }
+    return {
+      code: str,
+      offset: 0
+    };
+  }
+
+  static transformImportCode(prefix, str, node, specifiers, sourceNode, indexOffset = 0) {
+    let { start, end } = node;
+    start += indexOffset;
+    end += indexOffset;
+
+    let { raw: rawSourceValue } = sourceNode;
+
+    let importDeclaration = str.slice(start, end - 1);
+
+    let specifierIndexes = [];
+    if(importDeclaration.startsWith("import ")) {
+      specifierIndexes[0] = "import ".length + start;
+    } else {
+      throw new Error(`Could not find \`import\` in import declaration: ${importDeclaration}`);
+    }
+
+    specifierIndexes[1] = specifiers[specifiers.length - 1].end + indexOffset;
+
+    // normalize away trailing } on import { a, b, c } specifiers
+    let split = str.slice(specifierIndexes[1]).split(" from ");
+    if(split.length > 0) {
+      specifierIndexes[1] += split[0].length;
+    }
+
+    let newImportString = `const ${str.slice(specifierIndexes[0], specifierIndexes[1])} = ${prefix}(${rawSourceValue})`;
+    let returnedCode = str.slice(0, start) + newImportString + str.slice(end - 1);
+
+    return {
+      code: returnedCode,
+      offset: returnedCode.length - str.length,
+    };
+  }
+
+  _transform(prefix) {
+    let input = this.originalSource;
+    let indexOffset = 0;
+    for(let node of this.ast.body) {
+      if(node.type === "ImportDeclaration") {
+        let ret = ImportTransformer.transformImportCode(prefix, input, node, node.specifiers, node.source, indexOffset)
+        input = ret.code;
+        indexOffset += ret.offset;
+      }
+    }
+
+    return input;
+  }
+
+  transformToDynamicImport() {
+    return this._transform("await import");
+  }
+
+  transformToRequire() {
+    return this._transform("require");
+  }
+
+  // alias for backwards compat
+  transform(...args) {
+    return this.transformWithImportMap(...args);
+  }
+
+  transformWithImportMap(importMap) {
+    if(!importMap) {
+      return this.originalSource;
+    }
+
+    let input = this.originalSource;
+    let indexOffset = 0;
+    for(let node of this.ast.body) {
+      if(node.type === "ImportDeclaration") {
+        if(importMap?.imports) {
+          let ret = ImportTransformer.transformImportSource(input, node.source, indexOffset, importMap);
+          input = ret.code;
+          indexOffset += ret.offset;
+        }
+      }
+    }
+
+    return input;
+  }
+
+  hasImports() {
+    for(let node of this.ast.body) {
+      if(node.type === "ImportDeclaration") {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

node_modules/esm-import-transformer/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "esm-import-transformer",
+  "version": "3.0.2",
+  "description": "Perform transformations on ESM import syntax (using import maps or to a dynamic import).",
+  "type": "module",
+  "main": "./import-transformer.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zachleat/esm-import-transformer.git"
+  },
+  "author": {
+    "name": "Zach Leatherman",
+    "email": "zachleatherman@gmail.com",
+    "url": "https://zachleat.com/"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "npx ava"
+  },
+  "dependencies": {
+    "acorn": "^8.11.2"
+  },
+  "devDependencies": {
+    "ava": "^5.3.1"
+  }
+}

node_modules/esm-import-transformer/test/commonjsTest.cjs

@@ -0,0 +1,16 @@
+const test = require("ava");
+
+test("Full URL", async t => {
+  const { ImportTransformer } = await import("../import-transformer.js");
+
+  let before = `import {html, css, LitElement} from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `import {html, css, LitElement} from "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js";`;
+
+  t.is(tf.transformWithImportMap({
+    imports: {
+      lit: "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js"
+    }
+  }), after);
+});

node_modules/esm-import-transformer/test/test.js

@@ -0,0 +1,217 @@
+import test from "ava";
+import * as acorn from "acorn";
+import { ImportTransformer } from "../import-transformer.js";
+
+test("No import maps", t => {
+  let before = `import {html, css, LitElement} from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  t.is(tf.transformWithImportMap(), before);
+});
+
+test("Simple substitution", t => {
+  let before = `import {html, css, LitElement} from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `import {html, css, LitElement} from "other-lit-url";`;
+
+  t.is(tf.transformWithImportMap({
+    imports: {
+      lit: "other-lit-url"
+    }
+  }), after);
+});
+
+test("Simple substitution (backwards compat method)", t => {
+  let before = `import {html, css, LitElement} from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `import {html, css, LitElement} from "other-lit-url";`;
+
+  t.is(tf.transform({
+    imports: {
+      lit: "other-lit-url"
+    }
+  }), after);
+});
+
+test("Simple substitution (manual supply of ast)", t => {
+  let before = `import {html, css, LitElement} from "lit";`;
+  let ast = acorn.parse(before, {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  });
+  let tf = new ImportTransformer(before, ast);
+
+  let after = `import {html, css, LitElement} from "other-lit-url";`;
+
+  t.is(tf.transformWithImportMap({
+    imports: {
+      lit: "other-lit-url"
+    }
+  }), after);
+});
+
+test("Multiple substitutions", t => {
+  let before = `
+import all from "lit";
+import all2 from "lit2";
+import all3 from "lit";
+`;
+  let tf = new ImportTransformer(before);
+
+  let after = `
+import all from "other-lit-url";
+import all2 from "other-lit-url2";
+import all3 from "other-lit-url";
+`;
+
+  t.is(tf.transformWithImportMap({
+    imports: {
+      lit: "other-lit-url",
+      lit2: "other-lit-url2"
+    }
+  }), after);
+});
+
+test("Full URL", t => {
+  let before = `import {html, css, LitElement} from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `import {html, css, LitElement} from "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js";`;
+
+  t.is(tf.transformWithImportMap({
+    imports: {
+      lit: "https://cdn.jsdelivr.net/gh/lit/dist@2/core/lit-core.min.js"
+    }
+  }), after);
+});
+
+test("Change to dynamic import (default)", t => {
+  let before = `import noop from "@zachleat/noop";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const noop = await import("@zachleat/noop");`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+test("Change to dynamic import (destructured)", t => {
+  let before = `import { html, css, LitElement } from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { html, css, LitElement } = await import("lit");`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+test("Change to dynamic import (multiple)", t => {
+  let before = `import { html, css, LitElement } from "lit";
+import noop from "@zachleat/noop";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { html, css, LitElement } = await import("lit");
+const noop = await import("@zachleat/noop");`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+test("Change to dynamic import (multiple ×3)", t => {
+  let before = `import { html, css, LitElement } from "lit";
+import noop from "@zachleat/noop";
+import noop2 from "@zachleat/noop";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { html, css, LitElement } = await import("lit");
+const noop = await import("@zachleat/noop");
+const noop2 = await import("@zachleat/noop");`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+// TODO
+test.skip("Change to dynamic import, multiple types", t => {
+  let before = `import myDefault, { myModule } from "/modules/my-module.js";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const myDefault = await import("my-module.js");const { myModule } = myDefault;`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+// TODO
+test.skip("Change to dynamic import with alias", t => {
+  let before = `import { reallyReallyLongModuleExportName as shortName } from "my-module.js";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { reallyReallyLongModuleExportName: shortName } = await import("my-module.js");`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+// TODO
+test.skip("Change to dynamic import with namespace", t => {
+  let before = `import * as name from "my-module.js";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `/* TODO */`;
+
+  t.is(tf.transformToDynamicImport(), after);
+});
+
+test("Change to require (default)", t => {
+  let before = `import noop from "@zachleat/noop";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const noop = require("@zachleat/noop");`;
+
+  t.is(tf.transformToRequire(), after);
+});
+
+
+test("Change to require (destructured)", t => {
+  let before = `import { html, css, LitElement } from "lit";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { html, css, LitElement } = require("lit");`;
+
+  t.is(tf.transformToRequire(), after);
+});
+
+test("Change to require (multiple)", t => {
+  let before = `import { html, css, LitElement } from "lit";
+import noop from "@zachleat/noop";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { html, css, LitElement } = require("lit");
+const noop = require("@zachleat/noop");`;
+
+  t.is(tf.transformToRequire(), after);
+});
+
+test("Change to require (multiple ×3)", t => {
+  let before = `import { html, css, LitElement } from "lit";
+import noop from "@zachleat/noop";
+import noop2 from "@zachleat/noop";`;
+  let tf = new ImportTransformer(before);
+
+  let after = `const { html, css, LitElement } = require("lit");
+const noop = require("@zachleat/noop");
+const noop2 = require("@zachleat/noop");`;
+
+  t.is(tf.transformToRequire(), after);
+});
+
+test("Test if has imports (using import)", t => {
+  let code = `import {html, css, LitElement} from "lit";`;
+  let tf = new ImportTransformer(code);
+
+  t.is(tf.hasImports(), true);
+});
+
+test("Test if has imports (using require)", t => {
+  let code = `const {html, css, LitElement} = require("lit");`;
+  let tf = new ImportTransformer(code);
+
+  t.is(tf.hasImports(), false);
+});