@sapphire/docusaurus-plugin-ts2esm2cjs 1.0.2-next.dfbe36e.0 → 1.0.2

package/dist/index.js

@@ -1,154 +1,486 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ts2esm2cjs = void 0;
-const tslib_1 = require("tslib");
-const prettier_config_1 = (0, tslib_1.__importDefault)(require("@sapphire/prettier-config"));
-const esm_to_cjs_1 = require("esm-to-cjs");
-const prettier_1 = (0, tslib_1.__importDefault)(require("prettier"));
-const typescript_1 = (0, tslib_1.__importDefault)(require("typescript"));
-const documentationPrettierConfig = {
-    ...prettier_config_1.default,
-    tabWidth: 2,
-    useTabs: false,
-    printWidth: 120,
-    parser: 'babel'
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-const makeTsCompilerOptions = (overrideOptions) => ({
-    newLine: typescript_1.default.NewLineKind.LineFeed,
-    removeComments: false,
-    esModuleInterop: true,
-    pretty: true,
-    ...overrideOptions,
-    module: typescript_1.default.ModuleKind.ESNext,
-    moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
-    target: typescript_1.default.ScriptTarget.ESNext
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/tsup/assets/cjs_shims.js"() {
+  }
 });
-/**
- * Transpiles input TypeScript code to ESM code.
- * @param code The code to transpile
- * @returns Input code transpiled to ESM
- */
-const tsToEsm = (code, options) => typescript_1.default.transpileModule(code, { reportDiagnostics: false, compilerOptions: makeTsCompilerOptions(options.typescriptCompilerOptions) });
-/**
- * Transforms input ESM code to CJS code.
- * @param code The code to transform
- * @returns Input code transformed to CommonJS
- */
-const esmToCjs = (code) => (0, esm_to_cjs_1.runTransform)(code, { quote: 'single', lenDestructure: 128, lenModuleName: 128, lenIdentifier: 128 });
-/**
- * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}
- * @param code The code to escape new lines in
- * @returns The same code but with new lines escaped using block comments
- */
-const escapeNewLines = (code) => code.replace(/\n\n/g, '\n/* :newline: */');
-/**
- * Reverses {@link escapeNewLines} and restores new lines
- * @param code The code with escaped new lines
- * @returns The same code with new lines restored
- */
-const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, '\n');
-/**
- * Formats the code using Prettier
- * @param code The code to prettier format
- * @param prettierConfig Additional prettier options to use for formatting
- * @returns Prettier formatted code
- */
-const prettierFormatCode = (code, prettierConfig) => prettier_1.default.format(code, { ...documentationPrettierConfig, ...prettierConfig }).slice(0, -1);
-/**
- * Transforms a Docusaurus node from TypeScript to ESM and CJS
- * @param node The Docusaurus node to transform
- * @param isSync Whether the transform should synchronize between all entries of this type
- * @returns The transformed node in the form of Tabs.
- */
-const transformNode = (node, options) => {
-    const groupIdProp = options.sync ? 'groupId="ts2esm2cjs" ' : '';
-    const tsCode = escapeNewLines(node.value);
-    const esmCode = tsToEsm(tsCode, { typescriptCompilerOptions: options.typescriptCompilerOptions }).outputText;
-    const cjsCode = esmToCjs(esmCode);
-    const [, jsHighlight, tsHighlight] = node.meta.split('|');
-    return [
-        {
-            type: 'jsx',
-            value: `<Tabs defaultValue="typescript" ${groupIdProp}` +
-                `values={[
+
+// src/esmToCjs.js
+var require_esmToCjs = __commonJS({
+  "src/esmToCjs.js"(exports, module2) {
+    init_cjs_shims();
+    module2.exports.runTransform = runTransform2;
+    var LOOKING_FOR;
+    var DISTANCE = 6;
+    var defaultOptions = {
+      quote: "double",
+      lenDestructure: 60,
+      lenModuleName: 20,
+      lenIdentifier: 20,
+      indent: 2
+    };
+    function runTransform2(str, options = {}) {
+      options = { ...defaultOptions, ...options };
+      options.quote = options.quote === "single" ? "'" : '"';
+      const buffer = [];
+      const exportBuffer = {
+        items: [],
+        requires: []
+      };
+      let pos = 0;
+      for (const token of tokenize(str, options)) {
+        buffer.push(str.slice(pos, token.start));
+        buffer.push(transform(token, str, exportBuffer, options));
+        pos = token.end + 1;
+      }
+      pos = skipNewLines(str, pos);
+      buffer.push(str.slice(pos, str.length));
+      if (exportBuffer.items.length) {
+        const indent = " ".repeat(options.indent);
+        for (const item of exportBuffer.requires) {
+          buffer.push(item);
+        }
+        buffer.push("\nmodule.exports = {\n");
+        const exportNames = exportBuffer.items.map((item) => `${indent}${item[0]}${item[1] ? `: ${item[1]}` : ""}`);
+        buffer.push(exportNames.join(",\n"));
+        buffer.push("\n}");
+      }
+      buffer.push("\n");
+      return buffer.join("");
+    }
+    function transform(token, str, exportBuffer, { indent }) {
+      indent = " ".repeat(indent);
+      const { type } = token;
+      switch (type) {
+        case "import": {
+          const identifiers = token.modules.map((s) => s.join(": ")).join(", ");
+          return `const { ${identifiers} } = require(${token.moduleName})`;
+        }
+        case "import*":
+        case "importDefault": {
+          const { identifier, moduleName } = token;
+          return `const ${identifier} = require(${moduleName})${token.isDefaultImport ? ".default" : ""}`;
+        }
+        case "awaitImport": {
+          return `require(${token.moduleName})`;
+        }
+        case "export": {
+          exportBuffer.items.push(token.modules);
+          return "";
+        }
+        case "reExport": {
+          const { moduleName } = token;
+          if (token.modules.length === 1) {
+            const [original, alias] = token.modules[0];
+            exportBuffer.items.push([alias ? alias : original, `require(${moduleName}).${original}`]);
+            return;
+          }
+          exportBuffer.requires.push("const {\n");
+          const names = token.modules.map(([original]) => `${indent}${original}: __${original}__`).join(",\n");
+          exportBuffer.requires.push(names);
+          exportBuffer.requires.push(`
+} = require(${moduleName});`);
+          for (const [original, alias] of token.modules) {
+            exportBuffer.items.push([alias ? alias : original, `__${original}__`]);
+          }
+          return "";
+        }
+        case "reExportImported": {
+          exportBuffer.items.push(...token.modules);
+          return "";
+        }
+        default:
+          throw new Error("should not reach here");
+      }
+    }
+    String.prototype.indexWithin = indexWithin;
+    function* tokenize(str, options) {
+      const { quote, lenDestructure, lenModuleName, lenIdentifier } = options;
+      let start = 0;
+      let pos;
+      const types = /* @__PURE__ */ new Map([
+        ["import", "import "],
+        ["export", "export "],
+        ["awaitImport", "await import("]
+      ]);
+      while (types.size !== 0) {
+        pos = Number.POSITIVE_INFINITY;
+        let type;
+        for (const t of types.keys()) {
+          const idx = str.indexOf(types.get(t), start);
+          if (idx === -1) {
+            types.delete(t);
+          } else if (idx < pos) {
+            pos = idx;
+            type = t;
+          }
+        }
+        switch (type) {
+          case "import":
+            yield handleImport();
+            break;
+          case "export":
+            yield handleExport();
+            break;
+          case "awaitImport":
+            yield handleAwaitImport();
+            break;
+        }
+      }
+      function handleImport() {
+        LOOKING_FOR = "import names";
+        const braceStart = str.indexWithin("{", pos + 7, DISTANCE, false);
+        if (braceStart === -1) {
+          return handleImportStar();
+        }
+        const braceEnd = str.indexWithin("}", braceStart + 1, lenDestructure);
+        LOOKING_FOR = "name of imported module";
+        let moduleStart = str.indexWithin("from ", braceEnd + 1, DISTANCE);
+        moduleStart = str.indexWithin(quote, moduleStart + 1, 5);
+        const moduleEnd = str.indexWithin(quote, moduleStart + 1, lenModuleName);
+        start = moduleEnd + 1;
+        return {
+          type: "import",
+          start: pos,
+          end: moduleEnd,
+          modules: destructureModules(str.slice(braceStart, braceEnd + 1)),
+          moduleName: str.slice(moduleStart, moduleEnd + 1)
+        };
+      }
+      function handleAwaitImport() {
+        LOOKING_FOR = "name of imported module for await import()";
+        const moduleStart = str.indexWithin("(", pos + 12, 10) + 1;
+        const moduleEnd = str.indexWithin(")", moduleStart + 1, lenIdentifier) - 1;
+        start = moduleEnd + 2;
+        return {
+          type: "awaitImport",
+          start: pos,
+          end: moduleEnd + 1,
+          moduleName: str.slice(moduleStart, moduleEnd + 1)
+        };
+      }
+      function handleExport() {
+        LOOKING_FOR = "export pattern";
+        let skipStart = pos + "export ".length;
+        if (str.indexWithin("{", skipStart, 5, false) !== -1) {
+          return handleReExport();
+        } else if (str.indexWithin("*", skipStart, 5, false) !== -1) {
+          return handleExportStar();
+        }
+        LOOKING_FOR = "identifier type (function|class|const) for export";
+        if (str.indexWithin("async ", skipStart, DISTANCE, false) !== -1) {
+          skipStart += 6;
+        }
+        let isDefaultExport = false;
+        if (str.indexWithin("default ", skipStart, DISTANCE, false) !== -1) {
+          skipStart += 8;
+          isDefaultExport = true;
+        }
+        const typeEnd = str.indexWithin(" ", skipStart, 9);
+        const exportType = str.slice(skipStart, typeEnd);
+        LOOKING_FOR = "export identifiers";
+        const identifierStart = str.indexWithin(" ", skipStart + exportType.length, 5) + 1;
+        const identifierEnd = str.indexWithin(exportType === "function" ? "(" : " ", identifierStart, lenIdentifier) - 1;
+        const end = pos + 6 + (isDefaultExport ? 8 : 0);
+        const modules = isDefaultExport ? ["default", str.slice(identifierStart, identifierEnd + 1)] : [str.slice(identifierStart, identifierEnd + 1)];
+        start = end + 1;
+        return {
+          type: "export",
+          start: pos,
+          end,
+          modules
+        };
+      }
+      function handleImportStar() {
+        LOOKING_FOR = "import name for import*";
+        let identifierStart = str.indexWithin("* as ", pos + 7, DISTANCE, false);
+        if (identifierStart === -1) {
+          return handleDefaultImport();
+        }
+        identifierStart += 5;
+        const identifierEnd = str.indexWithin(" ", identifierStart + 1, lenIdentifier);
+        LOOKING_FOR = "name of imported module for import*";
+        let moduleStart = str.indexWithin("from ", identifierEnd + 1) + "from".length;
+        moduleStart = str.indexWithin(quote, moduleStart + 1);
+        const moduleEnd = str.indexWithin(quote, moduleStart + 1, lenModuleName);
+        start = moduleEnd + 1;
+        return {
+          type: "import*",
+          start: pos,
+          end: moduleEnd,
+          identifier: str.slice(identifierStart, identifierEnd),
+          moduleName: str.slice(moduleStart, moduleEnd + 1)
+        };
+      }
+      function handleDefaultImport() {
+        LOOKING_FOR = "import name for default import";
+        const identifierStart = pos + 7;
+        const identifierEnd = str.indexWithin(" ", identifierStart, DISTANCE);
+        LOOKING_FOR = "name of imported module for import*";
+        let moduleStart = str.indexWithin("from ", identifierEnd + 1) + "from".length;
+        moduleStart = str.indexWithin(quote, moduleStart + 1);
+        const moduleEnd = str.indexWithin(quote, moduleStart + 1, lenModuleName);
+        start = moduleEnd + 1;
+        return {
+          type: "importDefault",
+          start: pos,
+          end: moduleEnd,
+          isDefaultImport: true,
+          identifier: str.slice(identifierStart, identifierEnd),
+          moduleName: str.slice(moduleStart, moduleEnd + 1)
+        };
+      }
+      function handleReExport() {
+        LOOKING_FOR = "export pattern for re-export";
+        const braceStart = str.indexWithin("{", pos + "export ".length, 5);
+        const braceEnd = str.indexWithin("}", braceStart + 1, lenDestructure);
+        LOOKING_FOR = "name of re-exported module";
+        let moduleStart = str.indexWithin("from ", braceEnd + 1, 10, false);
+        if (moduleStart === -1) {
+          const end2 = skipNewLines(str, braceEnd);
+          start = end2 + 1;
+          return {
+            type: "reExportImported",
+            start: pos,
+            end: end2,
+            modules: destructureModules(str.slice(braceStart, braceEnd + 1))
+          };
+        }
+        moduleStart = str.indexWithin(quote, moduleStart, "from ".length + 4);
+        const moduleEnd = str.indexWithin(quote, moduleStart + 1, lenModuleName);
+        const end = skipNewLines(str, moduleEnd);
+        start = end + 1;
+        return {
+          type: "reExport",
+          start: pos,
+          end,
+          modules: destructureModules(str.slice(braceStart, braceEnd + 1)),
+          moduleName: str.slice(moduleStart, moduleEnd + 1)
+        };
+      }
+      function handleExportStar() {
+        throw new Error("not implemented");
+      }
+      function destructureModules(objLiteral) {
+        return objLiteral.trim().slice(1, -1).split(/,\s*/).map((i) => i.trim()).filter((i) => i).map((i) => i.split(/\s*\bas\b\s*/));
+      }
+    }
+    function indexWithin(needle, from, within = 99, throws = true) {
+      for (let i = from, L = from + within, j = 0; i < L; ++i) {
+        if (this.charCodeAt(i) === needle.charCodeAt(j)) {
+          while (j < needle.length) {
+            if (this.charCodeAt(i + j) === needle.charCodeAt(j)) {
+              ++j;
+            } else {
+              j = 0;
+              break;
+            }
+          }
+          if (j === needle.length) {
+            return i;
+          }
+        }
+      }
+      if (throws) {
+        throw new Error(`ParseError: Failed to find \`${needle}\` within ${within} characters from position ${from}${LOOKING_FOR ? ` while looking for ${LOOKING_FOR}` : ""}
+
+INPUT STRING:
+${"*".repeat(20)}
+${this}
+${"*".repeat(20)}
+`);
+      } else {
+        return -1;
+      }
+    }
+    function skipNewLines(str, i) {
+      if (str.charAt(i + 1) === ";")
+        ++i;
+      while (i < str.length && /\s/.test(str.charAt(i))) {
+        ++i;
+      }
+      return i;
+    }
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  documentationPrettierConfig: () => documentationPrettierConfig,
+  escapeNewLines: () => escapeNewLines,
+  esmToCjs: () => esmToCjs,
+  makeTsCompilerOptions: () => makeTsCompilerOptions,
+  prettierFormatCode: () => prettierFormatCode,
+  restoreNewLines: () => restoreNewLines,
+  ts2esm2cjs: () => ts2esm2cjs,
+  tsToEsm: () => tsToEsm
+});
+init_cjs_shims();
+var import_prettier_config = __toESM(require("@sapphire/prettier-config"));
+var import_esmToCjs = __toESM(require_esmToCjs());
+var import_prettier = __toESM(require("prettier"));
+var import_typescript = __toESM(require("typescript"));
+var documentationPrettierConfig = {
+  ...import_prettier_config.default,
+  tabWidth: 2,
+  useTabs: false,
+  printWidth: 120,
+  parser: "babel"
+};
+var makeTsCompilerOptions = (overrideOptions) => ({
+  newLine: import_typescript.default.NewLineKind.LineFeed,
+  removeComments: false,
+  esModuleInterop: true,
+  pretty: true,
+  ...overrideOptions,
+  module: import_typescript.default.ModuleKind.ESNext,
+  moduleResolution: import_typescript.default.ModuleResolutionKind.NodeJs,
+  target: import_typescript.default.ScriptTarget.ESNext
+});
+var tsToEsm = (code, options) => import_typescript.default.transpileModule(code, { reportDiagnostics: false, compilerOptions: makeTsCompilerOptions(options.typescriptCompilerOptions) });
+var esmToCjs = (code) => (0, import_esmToCjs.runTransform)(code, { quote: "single", lenDestructure: 512, lenModuleName: 512, lenIdentifier: 512 });
+var escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
+var restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
+var prettierFormatCode = (code, prettierConfig) => import_prettier.default.format(code, { ...documentationPrettierConfig, ...prettierConfig }).slice(0, -1);
+var transformNode = (node, options) => {
+  const groupIdProp = options.sync ? 'groupId="ts2esm2cjs" ' : "";
+  const tsCode = escapeNewLines(node.value);
+  const esmCode = tsToEsm(tsCode, { typescriptCompilerOptions: options.typescriptCompilerOptions }).outputText;
+  const cjsCode = esmToCjs(esmCode);
+  const [, jsHighlight, tsHighlight] = node.meta.split("|");
+  return [
+    {
+      type: "jsx",
+      value: `<Tabs defaultValue="typescript" ${groupIdProp}values={[
     { label: 'JavaScript', value: 'javascript', },
     { label: 'ESM', value: 'esm', },
     { label: 'TypeScript', value: 'typescript', },
   ]}
 >
 <TabItem value="javascript">`
-        },
-        {
-            type: node.type,
-            lang: node.lang,
-            meta: jsHighlight,
-            value: prettierFormatCode(restoreNewLines(cjsCode), options.prettierOptions)
-        },
-        {
-            type: 'jsx',
-            value: '</TabItem>\n<TabItem value="esm">'
-        },
-        {
-            type: node.type,
-            lang: node.lang,
-            meta: jsHighlight,
-            value: prettierFormatCode(restoreNewLines(esmCode), options.prettierOptions)
-        },
-        {
-            type: 'jsx',
-            value: '</TabItem>\n<TabItem value="typescript">'
-        },
-        {
-            type: node.type,
-            lang: node.lang,
-            meta: tsHighlight,
-            value: node.value
-        },
-        {
-            type: 'jsx',
-            value: '</TabItem>\n</Tabs>'
-        }
-    ];
+    },
+    {
+      type: node.type,
+      lang: node.lang,
+      meta: jsHighlight,
+      value: prettierFormatCode(restoreNewLines(cjsCode), options.prettierOptions)
+    },
+    {
+      type: "jsx",
+      value: '</TabItem>\n<TabItem value="esm">'
+    },
+    {
+      type: node.type,
+      lang: node.lang,
+      meta: jsHighlight,
+      value: prettierFormatCode(restoreNewLines(esmCode), options.prettierOptions)
+    },
+    {
+      type: "jsx",
+      value: '</TabItem>\n<TabItem value="typescript">'
+    },
+    {
+      type: node.type,
+      lang: node.lang,
+      meta: tsHighlight,
+      value: node.value
+    },
+    {
+      type: "jsx",
+      value: "</TabItem>\n</Tabs>"
+    }
+  ];
 };
-const matchNode = (node) => node.type === 'code' && typeof node.meta === 'string' && node.meta.startsWith('ts2esm2cjs');
-const nodeForImport = {
-    type: 'import',
-    value: "import Tabs from '@theme/Tabs';\nimport TabItem from '@theme/TabItem';"
+var matchNode = (node) => node.type === "code" && typeof node.meta === "string" && node.meta.startsWith("ts2esm2cjs");
+var nodeForImport = {
+  type: "import",
+  value: "import Tabs from '@theme/Tabs';\nimport TabItem from '@theme/TabItem';"
 };
 function ts2esm2cjs({ sync = true, prettierOptions = {}, typescriptCompilerOptions = {} } = {
-    sync: true,
-    prettierOptions: {},
-    typescriptCompilerOptions: {}
+  sync: true,
+  prettierOptions: {},
+  typescriptCompilerOptions: {}
 }) {
-    let transformed = false;
-    let alreadyImported = false;
-    const transformer = (node) => {
-        if (node.type === 'import' && node.value.includes('@theme/Tabs')) {
-            alreadyImported = true;
-        }
-        if (matchNode(node)) {
-            transformed = true;
-            return transformNode(node, { sync, prettierOptions, typescriptCompilerOptions });
-        }
-        if (Array.isArray(node.children)) {
-            let index = 0;
-            while (index < node.children.length) {
-                const result = transformer(node.children[index]);
-                if (result) {
-                    node.children.splice(index, 1, ...result);
-                    index += result.length;
-                }
-                else {
-                    index += 1;
-                }
-            }
+  let transformed = false;
+  let alreadyImported = false;
+  const transformer = (node) => {
+    if (node.type === "import" && node.value.includes("@theme/Tabs")) {
+      alreadyImported = true;
+    }
+    if (matchNode(node)) {
+      transformed = true;
+      return transformNode(node, { sync, prettierOptions, typescriptCompilerOptions });
+    }
+    if (Array.isArray(node.children)) {
+      let index = 0;
+      while (index < node.children.length) {
+        const result = transformer(node.children[index]);
+        if (result) {
+          node.children.splice(index, 1, ...result);
+          index += result.length;
+        } else {
+          index += 1;
         }
-        if (node.type === 'root' && transformed && !alreadyImported) {
-            node.children.unshift(nodeForImport);
-        }
-        return null;
-    };
-    return transformer;
+      }
+    }
+    if (node.type === "root" && transformed && !alreadyImported) {
+      node.children.unshift(nodeForImport);
+    }
+    return null;
+  };
+  return transformer;
 }
-exports.ts2esm2cjs = ts2esm2cjs;
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  documentationPrettierConfig,
+  escapeNewLines,
+  esmToCjs,
+  makeTsCompilerOptions,
+  prettierFormatCode,
+  restoreNewLines,
+  ts2esm2cjs,
+  tsToEsm
+});
+/**
+ * @license MIT
+ * @copyright 2018 Sid Vishnoi <sidvishnoi8@gmail.com>
+ * @see https://github.com/sidvishnoi/esm-to-cjs/blob/d032518da994b6d28cff5fd38ac2d0b45a13f0d9/src/core.js
+ *
+ * Modified code is line 340
+ */
 //# sourceMappingURL=index.js.map